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_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): 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, 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): 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 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): 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 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 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(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.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 validate_NetworkOffering(self, net_offering, state=None): """Validates the Network offering""" self.debug("Check if the Network offering is created successfully ?") net_offs = NetworkOffering.list(self.api_client, id=net_offering.id ) self.assertEqual(isinstance(net_offs, list), True, "List Network offering should return a valid list" ) self.assertEqual(net_offering.name, net_offs[0].name, "Name of the Network offering should match with the returned list data" ) if state: self.assertEqual(net_offs[0].state, state, "Network offering state should be in state - %s" % state ) self.debug("Network offering creation successfully validated for %s" % net_offering.name)
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 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): cls.logger = logging.getLogger('TestVPCSite2SiteVPN') cls.stream_handler = logging.StreamHandler() cls.logger.setLevel(logging.DEBUG) cls.logger.addHandler(cls.stream_handler) testClient = super(TestVpcSite2SiteVpn, cls).getClsTestClient() cls.apiclient = testClient.getApiClient() cls.services = Services().services cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests()) cls.domain = get_domain(cls.apiclient) cls.compute_offering = ServiceOffering.create( cls.apiclient, cls.services["compute_offering"] ) cls.account = Account.create( cls.apiclient, services=cls.services["account"]) cls.hypervisor = testClient.getHypervisorInfo() cls.logger.debug("Downloading Template: %s from: %s" % (cls.services["template"][ cls.hypervisor.lower()], cls.services["template"][cls.hypervisor.lower()]["url"])) cls.template = Template.register(cls.apiclient, cls.services["template"][cls.hypervisor.lower( )], cls.zone.id, hypervisor=cls.hypervisor.lower(), account=cls.account.name, domainid=cls.domain.id) cls.template.download(cls.apiclient) if cls.template == FAILED: assert False, "get_template() failed to return template" cls.logger.debug("Successfully created account: %s, id: \ %s" % (cls.account.name, cls.account.id)) cls.networkoffering = NetworkOffering.list( cls.apiclient, name="DefaultIsolatedNetworkOfferingForVpcNetworks") assert cls.networkoffering is not None and len( cls.networkoffering) > 0, "No VPC based network offering" cls._cleanup = [cls.template, cls.account, cls.compute_offering] return
def validate_NetworkOffering(self, net_offering, state=None): """Validates the Network offering""" self.debug("Validating the creation and state of Network offering - %s" % net_offering.name) net_offs = NetworkOffering.list(self.api_client, id=net_offering.id ) self.assertEqual(isinstance(net_offs, list), True, "List Network offering should return a valid list" ) self.assertEqual(net_offering.name, net_offs[0].name, "Name of the Network offering should match with the " "returned list data" ) if state: self.assertEqual(net_offs[0].state, state, "Network offering state should be '%s'" % state ) self.debug("Successfully validated the creation and state of Network " "offering - %s" % net_offering.name)
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): 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 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 test_19_template_tag(self): """ Test creation, listing and deletion tag on templates """ try: noffering=NetworkOffering.list( self.user_api_client, name="DefaultIsolatedNetworkOfferingWithSourceNatService" ) vm4network=Network.create( self.user_api_client, self.services["network"], accountid=self.account.name, domainid=self.account.domainid, networkofferingid=noffering[0].id, zoneid=self.zone.id ) list_nw_response = Network.list( self.user_api_client, id=vm4network.id ) self.assertEqual( isinstance(list_nw_response, list), True, "Check list response returns a valid networks list" ) vm_1 = VirtualMachine.create( self.user_api_client, self.services["small"], templateid=self.template.id, networkids=vm4network.id, serviceofferingid=self.service_offering.id, accountid=self.account.name, domainid=self.account.domainid, mode=self.services['mode'], startvm="true" ) time.sleep(600) self.debug("Stopping the virtual machine: %s" % vm_1.name) # Stop virtual machine vm_1.stop(self.user_api_client) except Exception as e: self.fail("Failed to stop VM: %s" % e) timeout = self.services["timeout"] while True: list_volume = Volume.list( self.user_api_client, virtualmachineid=vm_1.id, type='ROOT', listall=True ) if isinstance(list_volume, list): break elif timeout == 0: raise Exception("List volumes failed.") time.sleep(5) timeout = timeout - 1 self.volume = list_volume[0] self.debug("Creating template from ROOT disk of virtual machine: %s" % vm_1.name) # Create template from volume template = Template.create( self.user_api_client, self.services["template"], self.volume.id ) self.cleanup.append(template) self.debug("Created the template(%s). Now restarting the userVm: %s" % (template.name, vm_1.name)) vm_1.start(self.user_api_client) self.debug("Creating a tag for the template") tag = Tag.create( self.user_api_client, resourceIds=template.id, resourceType='Template', tags={'OS': 'windows8'} ) self.debug("Tag created: %s" % tag.__dict__) tags = Tag.list( self.user_api_client, listall=True, resourceType='Template', key='OS', value='windows8' ) self.assertEqual( isinstance(tags, list), True, "List tags should not return empty response" ) self.assertEqual( tags[0].value, 'windows8', 'The tag should have original value' ) Template.list( self.user_api_client, templatefilter=self.services["template"]["templatefilter"], listall=True, key='OS', value='windows8' ) self.debug("Deleting the created tag..") try: tag.delete( self.user_api_client, resourceIds=template.id, resourceType='Template', tags={'OS': 'windows8'} ) except Exception as e: self.fail("Failed to delete the tag - %s" % e) self.debug("Verifying if tag is actually deleted!") tags = Tag.list( self.user_api_client, listall=True, resourceType='Template', key='OS', value='windows8' ) self.assertEqual( tags, None, "List tags should return empty response" ) return
def setUp(self): self.testdata = self.testClient.getParsedTestDataConfig()["vgpu"] self.apiclient = self.testClient.getApiClient() self.dbclient = self.testClient.getDbConnection() if self.noSuitableHost or self.unsupportedHypervisor: self.hypervisor = get_hypervisor_type(self.apiclient) if self.hypervisor.lower() not in ["vmware"]: self.skipTest( "Skipping test because suitable hypervisor/host not\ present") self.testdata = self.testClient.getParsedTestDataConfig() self.cleanup = [] # Get Zone, Domain and Default Built-in template self.domain = get_domain(self.apiclient) self.zone = get_zone(self.apiclient, self.testClient.getZoneForTests()) # Creating Account self.account = Account.create(self.apiclient, self.testdata["account"], domainid=self.domain.id) if self.hypervisor.lower() in ["xenserver"]: # Before running this test for Xen Server, register a windows template with ostype as # 'Windows 7 (32-bit)' self.template = get_template(self.apiclient, self.zone.id, self.testdata["ostype"]) self.cleanup.append(self.template) self.testdata["mode"] = self.zone.networktype if self.template == FAILED: assert False, "get_template() failed to return template with description %s" % self.testdata[ "ostype"] self.testdata["small"]["zoneid"] = self.zone.id self.testdata["small"]["template"] = self.template.id self.testdata["service_offerings"]["vgpu260qwin"][ "serviceofferingdetails"] = [{ 'pciDevice': 'Group of NVIDIA Corporation GK107GL [GRID K1] GPUs' }, { 'vgpuType': 'GRID K120Q' }] # create a service offering self.service_offering = ServiceOffering.create( self.apiclient, self.testdata["service_offerings"]["vgpu260qwin"], ) self.cleanup.append(self.service_offering) elif self.hypervisor.lower() in ["vmware"]: self.testdata["isolated_network"]["zoneid"] = self.zone.id self.userapiclient = self.testClient.getUserApiClient( UserName=self.account.name, DomainName=self.account.domain) self.service_offering = ServiceOffering.create( self.apiclient, self.testdata["service_offering"]) # Create Shared Network Offering self.isolated_network_offering = NetworkOffering.create( self.apiclient, self.testdata["isolated_network_offering"]) # Enable Isolated Network offering self.isolated_network_offering.update(self.apiclient, state='Enabled') # Register a private template in the account with nic adapter vmxnet3 # Also add required 3D GPU details for enabling it self.template = Template.register( self.userapiclient, self.testdata["configurableData"]["vmxnet3template"], zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, details=[{ "mks.enable3d": "true", "mks.use3dRenderer": "automatic", "svga.autodetect": "false", "svga.vramSize": "131072" }])
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 test_02_create_network_with_same_name(self): """Create Shared network with same name in same account Steps: # 1. Update the global setting allow.duplicate.networkname to true # 2. Create a shared network in an account # 3. Try to create another shared network with same name in the same account # 4. No exception should be thrown as multiple networks with same name can be created # 5. Now update the global setting allow.duplicate.networkname to false # 6. Try to create another shared network with same name in the same account # 7. Exception should be thrown as network with same name cant be created in the same account :return: """ # Update the global setting to true Configurations.update(self.apiclient, name="allow.duplicate.networkname", value="true") # Create network offering self.network_offering = NetworkOffering.create( self.apiclient, self.testdata["network_offering_shared"]) NetworkOffering.update(self.network_offering, self.apiclient, id=self.network_offering.id, state="enabled") physical_network, vlan = get_free_vlan(self.apiclient, self.zone.id) self.testdata["shared_network_sg"][ "physicalnetworkid"] = physical_network.id random_subnet_number = random.randrange(100, 199) self.testdata["shared_network_sg"]["specifyVlan"] = 'True' self.testdata["shared_network_sg"]["specifyIpRanges"] = 'True' self.testdata["shared_network_sg"][ "name"] = "Shared-Network-SG-Test-vlan-1" self.testdata["shared_network_sg"][ "displaytext"] = "Shared-Network-SG-Test-vlan-1" self.testdata["shared_network_sg"]["vlan"] = "vlan://" + str( random_subnet_number) self.testdata["shared_network_sg"]["startip"] = "192.168." + str( random_subnet_number) + ".1" self.testdata["shared_network_sg"]["endip"] = "192.168." + str( random_subnet_number) + ".10" self.testdata["shared_network_sg"]["gateway"] = "192.168." + str( random_subnet_number) + ".254" self.testdata["shared_network_sg"]["netmask"] = "255.255.255.0" self.testdata["shared_network_sg"]["acltype"] = "account" # Create the first network network3 = Network.create(self.apiclient, self.testdata["shared_network_sg"], networkofferingid=self.network_offering.id, zoneid=self.zone.id, accountid=self.account.name, domainid=self.account.domainid) self.cleanup.append(network3) # Create the second network with same name. No exception should be thrown random_subnet_number = random.randrange(100, 199) self.testdata["shared_network_sg"]["vlan"] = "vlan://" + str( random_subnet_number) network4 = Network.create(self.apiclient, self.testdata["shared_network_sg"], networkofferingid=self.network_offering.id, zoneid=self.zone.id, accountid=self.account.name, domainid=self.account.domainid) self.cleanup.append(network4) # Update the global setting to true Configurations.update(self.apiclient, name="allow.duplicate.networkname", value="false") # Exception should be thrown while creating another network with same name with self.assertRaises(Exception): random_subnet_number = random.randrange(100, 199) self.testdata["shared_network_sg"]["vlan"] = "vlan://" + str( random_subnet_number) network5 = Network.create( self.apiclient, self.testdata["shared_network_sg"], networkofferingid=self.network_offering.id, zoneid=self.zone.id, accountid=self.account.name, domainid=self.account.domainid) # Update the global setting to original value Configurations.update(self.apiclient, name="allow.duplicate.networkname", value="true") self.cleanup.append(self.network_offering)
def test_02_native_to_native_vpc_migration(self): """ Verify Migration for a vpc network nativeOnly 1. create native vpc with 2 tier networks 2. migrate to native vpc, check VR state 3. deploy VM in vpc tier network 4. acquire ip and enable staticnat 5. migrate to native vpc network """ self.debug("Creating Native VSP VPC offering with Static NAT service " "provider as VPCVR...") native_vpc_off = VpcOffering.create( self.apiclient, self.test_data["vpc_offering_reduced"]) self.debug("Enabling the VPC offering created") native_vpc_off.update(self.apiclient, state='Enabled') self.debug("Creating a VPC with Static NAT service provider as " "VpcVirtualRouter") self.services["vpc"]["cidr"] = '10.1.1.1/16' vpc = VPC.create( self.apiclient, self.services["vpc"], vpcofferingid=native_vpc_off.id, zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid ) self.debug("Creating native VPC Network Tier offering " "with Static NAT service provider as VPCVR") native_tiernet_off = \ NetworkOffering.create(self.apiclient, self.test_data ["nw_offering_reduced_vpc"], conservemode=False) native_tiernet_off.update(self.apiclient, state='Enabled') self.debug("Creating a VPC tier network with Static NAT service") vpc_tier = Network.create(self.apiclient, self.services["network"], accountid=self.account.name, domainid=self.account.domainid, networkofferingid=native_tiernet_off.id, zoneid=self.zone.id, gateway='10.1.1.1', vpcid=vpc.id if vpc else self.vpc.id ) self.debug("Created network with ID: %s" % vpc_tier.id) network_offering_map = \ [{"networkid": vpc_tier.id, "networkofferingid": self.native_vpc_network_offering.id}] self.migrate_vpc(vpc, native_vpc_off, network_offering_map, resume=False) network_offering_map = \ [{"networkid": vpc_tier.id, "networkofferingid": native_tiernet_off.id}] self.migrate_vpc(vpc, native_vpc_off, network_offering_map, resume=False) self.debug('Creating VM in network=%s' % native_tiernet_off.name) vm = VirtualMachine.create( self.apiclient, self.services["virtual_machine"], accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.service_offering.id, networkids=[str(vpc_tier.id)], templateid=self.template.id, zoneid=self.zone.id ) self.debug('Created VM=%s in network=%s' % (vm.id, native_tiernet_off.name)) network_offering_map = \ [{"networkid": vpc_tier.id, "networkofferingid": self.native_vpc_network_offering.id}] self.migrate_vpc(vpc, native_vpc_off, network_offering_map, resume=False) network_offering_map = \ [{"networkid": vpc_tier.id, "networkofferingid": native_tiernet_off.id}] self.migrate_vpc(vpc, native_vpc_off, network_offering_map, resume=False)
def setUpClass(cls): """ Create the following domain tree and accounts that are required for executing Nuage VSP SDN plugin test cases for shared networks: Under ROOT - create domain D1 Under domain D1 - Create two subdomains D11 and D12 Under each of the domains - create one admin user and couple of regular users. Create shared network with the following scope: 1. Network with scope="all" 2. Network with scope="domain" with no subdomain access 3. Network with scope="domain" with subdomain access 4. Network with scope="account" """ super(TestNuageSharedNetworkVpcVmMonitor, cls).setUpClass() cls.sharednetworkdata = cls.test_data["acl"] cls.nuagenetworkdata = cls.test_data["nuagevsp"] cls.domain_1 = None cls.domain_2 = None try: # backup default apikey and secretkey cls.default_apikey = cls.api_client.connection.apiKey cls.default_secretkey = cls.api_client.connection.securityKey # Create domains cls.domain_1 = Domain.create(cls.api_client, cls.sharednetworkdata["domain1"]) cls.domain_11 = Domain.create(cls.api_client, cls.sharednetworkdata["domain11"], parentdomainid=cls.domain_1.id) cls.domain_12 = Domain.create(cls.api_client, cls.sharednetworkdata["domain12"], parentdomainid=cls.domain_1.id) # Create 1 admin account and 2 user accounts for doamin_1 cls.account_d1 = Account.create(cls.api_client, cls.sharednetworkdata["accountD1"], admin=True, domainid=cls.domain_1.id) user = cls.generateKeysForUser(cls.api_client, cls.account_d1) cls.user_d1_apikey = user.apikey cls.user_d1_secretkey = user.secretkey cls.account_d1a = Account.create( cls.api_client, cls.sharednetworkdata["accountD1A"], admin=False, domainid=cls.domain_1.id) user = cls.generateKeysForUser(cls.api_client, cls.account_d1a) cls.user_d1a_apikey = user.apikey cls.user_d1a_secretkey = user.secretkey cls.account_d1b = Account.create( cls.api_client, cls.sharednetworkdata["accountD1B"], admin=False, domainid=cls.domain_1.id) user = cls.generateKeysForUser(cls.api_client, cls.account_d1b) cls.user_d1b_apikey = user.apikey cls.user_d1b_secretkey = user.secretkey # Create 1 admin and 2 user accounts for doamin_11 cls.account_d11 = Account.create( cls.api_client, cls.sharednetworkdata["accountD11"], admin=True, domainid=cls.domain_11.id) user = cls.generateKeysForUser(cls.api_client, cls.account_d11) cls.user_d11_apikey = user.apikey cls.user_d11_secretkey = user.secretkey cls.account_d11a = Account.create( cls.api_client, cls.sharednetworkdata["accountD11A"], admin=False, domainid=cls.domain_11.id) user = cls.generateKeysForUser(cls.api_client, cls.account_d11a) cls.user_d11a_apikey = user.apikey cls.user_d11a_secretkey = user.secretkey cls.account_d11b = Account.create( cls.api_client, cls.sharednetworkdata["accountD11B"], admin=False, domainid=cls.domain_11.id) user = cls.generateKeysForUser(cls.api_client, cls.account_d11b) cls.user_d11b_apikey = user.apikey cls.user_d11b_secretkey = user.secretkey # Create 2 user accounts for doamin_12 cls.account_d12a = Account.create( cls.api_client, cls.sharednetworkdata["accountD12A"], admin=False, domainid=cls.domain_12.id) user = cls.generateKeysForUser(cls.api_client, cls.account_d12a) cls.user_d12a_apikey = user.apikey cls.user_d12a_secretkey = user.secretkey cls.account_d12b = Account.create( cls.api_client, cls.sharednetworkdata["accountD12B"], admin=False, domainid=cls.domain_12.id) user = cls.generateKeysForUser(cls.api_client, cls.account_d12b) cls.user_d12b_apikey = user.apikey cls.user_d12b_secretkey = user.secretkey # Create 1 user account and admin account in "ROOT" domain cls.account_roota = Account.create( cls.api_client, cls.sharednetworkdata["accountROOTA"], admin=False, ) user = cls.generateKeysForUser(cls.api_client, cls.account_roota) cls.user_roota_apikey = user.apikey cls.user_roota_secretkey = user.secretkey cls.account_root = Account.create( cls.api_client, cls.sharednetworkdata["accountROOTA"], admin=True, ) user = cls.generateKeysForUser(cls.api_client, cls.account_root) cls.user_root_apikey = user.apikey cls.user_root_secretkey = user.secretkey # service offering is already created in Nuagetestcase cls.sharednetworkdata['mode'] = cls.zone.networktype # As admin user , create shared network with scope "all", "domain" # with subdomain access , "domain" without subdomain access and # "account" cls.api_client.connection.apiKey = cls.default_apikey cls.api_client.connection.securityKey = cls.default_secretkey cls.shared_network_offering = NetworkOffering.create( cls.api_client, cls.test_data["nuagevsp"]["shared_nuage_network_offering"], conservemode=False) # Enable Network offering cls.shared_network_offering.update(cls.api_client, state='Enabled') cls.shared_network_offering_id = cls.shared_network_offering.id cls.shared_network_all = Network.create( cls.api_client, cls.test_data["nuagevsp"]["network_all"], networkofferingid=cls.shared_network_offering_id, zoneid=cls.zone.id) cls.shared_network_domain_d11 = Network.create( cls.api_client, cls.test_data["nuagevsp"] ["network_domain_with_no_subdomain_access"], networkofferingid=cls.shared_network_offering_id, zoneid=cls.zone.id, domainid=cls.domain_11.id, subdomainaccess=False) cls.shared_network_domain_with_subdomain_d11 = Network.create( cls.api_client, cls.test_data["nuagevsp"] ["network_domain_with_subdomain_access"], networkofferingid=cls.shared_network_offering_id, zoneid=cls.zone.id, domainid=cls.domain_11.id, subdomainaccess=True) cls.shared_network_account_d111a = Network.create( cls.api_client, cls.test_data["nuagevsp"]["network_account"], networkofferingid=cls.shared_network_offering_id, zoneid=cls.zone.id, domainid=cls.domain_11.id, accountid=cls.account_d11a.user[0].username) cls.debug("Creating Nuage VSP VPC offering...") cls.vpc_offering = VpcOffering.create( cls.api_client, cls.test_data["nuagevsp"]["vpc_offering"]) cls.vpc_offering.update(cls.api_client, state="Enabled") # Creating a VPC cls.debug("Creating a VPC with Nuage VSP VPC offering...") cls.test_data["vpc"]["cidr"] = '10.1.0.0/16' cls.vpcd11 = VPC.create(cls.api_client, cls.test_data["vpc"], vpcofferingid=cls.vpc_offering.id, zoneid=cls.zone.id, account=cls.account_d11a.name, domainid=cls.account_d11a.domainid) # Creating a network offering cls.debug("Creating Nuage Vsp VPC Network offering...") cls.network_offering = NetworkOffering.create( cls.api_client, cls.test_data["nuagevsp"]["vpc_network_offering"], conservemode=False) cls.network_offering.update(cls.api_client, state="Enabled") # Creating two VPC network in the VPC cls.debug("Creating a VPC network with Nuage Vsp VPC Network " "offering...") cls.test_data["network"]["netmask"] = "255.255.255.0" cls.vpc_network1 = Network.create( cls.api_client, cls.test_data["network"], accountid=cls.account_d11a.name, domainid=cls.account_d11a.domainid, networkofferingid=cls.network_offering.id, zoneid=cls.zone.id, gateway="10.1.1.1", vpcid=cls.vpcd11.id) cls.debug( "Creating a VPC Tier2 network with Nuage Vsp VPC Network " "offering...") cls.test_data["network"]["name"] = "Tier2" cls.vpc_network2 = Network.create( cls.api_client, cls.test_data["network"], accountid=cls.account_d11a.name, domainid=cls.account_d11a.domainid, networkofferingid=cls.network_offering.id, zoneid=cls.zone.id, gateway="10.1.2.1", vpcid=cls.vpcd11.id) cls.vmdata = {"name": "vmvpc1", "displayname": "vmvpc1"} # Deploying a VM in the VPC network cls.vmvpc1 = VirtualMachine.create( cls.api_client, cls.vmdata, zoneid=cls.zone.id, serviceofferingid=cls.service_offering.id, templateid=cls.template.id, networkids=cls.vpc_network1.id, accountid=cls.account_d11a.name, domainid=cls.account_d11a.domainid) cls.vmdata = {"name": "vmvpc2", "displayname": "vmvpc2"} cls.vmvpc2 = VirtualMachine.create( cls.api_client, cls.vmdata, zoneid=cls.zone.id, serviceofferingid=cls.service_offering.id, templateid=cls.template.id, networkids=cls.vpc_network2.id, accountid=cls.account_d11a.name, domainid=cls.account_d11a.domainid) cls._cleanup = [ cls.account_root, cls.account_roota, cls.shared_network_all, cls.shared_network_offering, cls.network_offering, cls.vpc_offering, cls.service_offering, ] except Exception as e: cls.domain_1.delete(cls.api_client, cleanup="true") cleanup_resources(cls.api_client, cls._cleanup) raise Exception( "Failed to create the setup required to execute the test " "cases: %s" % e) return
def setUpClass(cls): print "In setup class" 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() print "in cls.setupClass- resp: %s" % resp resp.zoneid = cls.zone.id physical_networks = cls.api_client.listPhysicalNetworks(resp) for pn in physical_networks: if pn.isolationmethods == 'VSP': physical_network = pn #if isinstance(physical_networks, list): # physical_network = physical_networks[1] 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) #Get NSP ID nw_service_providers = cls.api_client.listNetworkServiceProviders( resp) cls.debug("NuageVsp NSP ID: %s" % nw_service_providers[0].id) 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.port = cls.nuage_services["port"] 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) #Enable NuageVsp NSP cls.debug("NuageVsp NSP ID : %s" % nw_service_providers[0].id) resp_up_nsp = \ updateNetworkServiceProvider.updateNetworkServiceProviderCmd() resp_up_nsp.id = nw_service_providers[0].id resp_up_nsp.state = 'Enabled' cls.api_client.updateNetworkServiceProvider(resp_up_nsp) 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 unittest.SkipTest("Unable to add VSP device") return
def test_03_deploy_vms_in_vpc_with_regionlevelvpc(self): """Test deploy virtual machines in VPC networks""" # 1. Create VPC Offering by specifying all supported Services # (Vpn,dhcpdns,UserData, SourceNat,Static NAT and PF,LB,NetworkAcl) # 2. Create a VPC using the above VPC offering # 3. Create a network as part of this VPC. # 4. Deploy few Vms. # 5. Create a LB rule for this VM. # 6. Create a PF rule for this VM. # 7. Create a Static Nat rule for this VM. # 8. Create Ingress rules on the network to open the above created # LB PF and Static Nat rule # 9. Create Egress Network ACL for this network to access google.com. # 10. Enable VPN services if not self.isOvsPluginEnabled: self.skipTest("OVS plugin should be enabled to run this test case") self.debug("Creating a VPC offering..") vpc_off = VpcOffering.create(self.apiclient, self.services["vpc_offering"]) vpc_off.update(self.apiclient, state='Enabled') self.debug("creating a VPC network in the account: %s" % self.account.name) vpc = VPC.create(self.apiclient, self.services["vpc"], vpcofferingid=vpc_off.id, zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, networkDomain=self.account.domainid) self.validate_vpc_network(vpc) self.network_offering = NetworkOffering.create( self.apiclient, self.services["network_offering"], conservemode=False) # Enable Network offering self.network_offering.update(self.apiclient, state='Enabled') gateway = vpc.cidr.split('/')[0] # Split the cidr to retrieve gateway # for eg. cidr = 10.0.0.1/24 # Gateway = 10.0.0.1 # Creating network using the network offering created self.debug("Creating network with network offering: %s" % self.network_offering.id) network = Network.create(self.apiclient, self.services["network"], accountid=self.account.name, domainid=self.account.domainid, networkofferingid=self.network_offering.id, zoneid=self.zone.id, gateway=gateway, vpcid=vpc.id) self.debug("Created network with ID: %s" % network.id) # Spawn an instance in that network virtual_machine = VirtualMachine.create( self.apiclient, self.services["virtual_machine"], accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.service_offering.id, networkids=[str(network.id)]) self.debug("Deployed VM in network: %s" % network.id) self.debug("Associating public IP for network: %s" % network.name) public_ip = PublicIPAddress.create(self.apiclient, accountid=self.account.name, zoneid=self.zone.id, domainid=self.account.domainid, networkid=network.id, vpcid=vpc.id) self.debug("Associated %s with network %s" % (public_ip.ipaddress.ipaddress, network.id)) self.debug("Creating LB rule for IP address: %s" % public_ip.ipaddress.ipaddress) LoadBalancerRule.create(self.apiclient, self.services["lbrule"], ipaddressid=public_ip.ipaddress.id, accountid=self.account.name, networkid=network.id, vpcid=vpc.id, domainid=self.account.domainid) self.debug("Associating public IP for network: %s" % vpc.name) public_ip_2 = PublicIPAddress.create(self.apiclient, accountid=self.account.name, zoneid=self.zone.id, domainid=self.account.domainid, networkid=network.id, vpcid=vpc.id) self.debug("Associated %s with network %s" % (public_ip_2.ipaddress.ipaddress, network.id)) NATRule.create(self.apiclient, virtual_machine, self.services["natrule"], ipaddressid=public_ip_2.ipaddress.id, openfirewall=False, networkid=network.id, vpcid=vpc.id) self.debug("Adding NetwrokACl rules to make PF and LB accessible") NetworkACL.create(self.apiclient, networkid=network.id, services=self.services["natrule"], traffictype='Ingress') NetworkACL.create(self.apiclient, networkid=network.id, services=self.services["lbrule"], traffictype='Ingress') self.debug("Checking if we can SSH into VM?") try: virtual_machine.get_ssh_client( ipaddress=public_ip_2.ipaddress.ipaddress, ) self.debug("SSH into VM is successfully") except Exception as e: self.fail("Failed to SSH into VM - %s, %s" % (public_ip_2.ipaddress.ipaddress, e)) self.debug("Associating public IP for network: %s" % network.name) public_ip_3 = PublicIPAddress.create(self.apiclient, accountid=self.account.name, zoneid=self.zone.id, domainid=self.account.domainid, networkid=network.id, vpcid=vpc.id) self.debug("Associated %s with network %s" % (public_ip_3.ipaddress.ipaddress, network.id)) self.debug("Enabling static NAT for IP: %s" % public_ip_3.ipaddress.ipaddress) try: StaticNATRule.enable(self.apiclient, ipaddressid=public_ip_3.ipaddress.id, virtualmachineid=virtual_machine.id, networkid=network.id) self.debug("Static NAT enabled for IP: %s" % public_ip_3.ipaddress.ipaddress) except Exception as e: self.fail("Failed to enable static NAT on IP: %s - %s" % (public_ip_3.ipaddress.ipaddress, e)) public_ips = PublicIPAddress.list(self.apiclient, networkid=network.id, listall=True, isstaticnat=True, account=self.account.name, domainid=self.account.domainid) self.assertEqual(isinstance(public_ips, list), True, "List public Ip for network should list the Ip addr") self.assertEqual(public_ips[0].ipaddress, public_ip_3.ipaddress.ipaddress, "List public Ip for network should list the Ip addr") # TODO: Remote Access VPN is not yet supported in VPC return
def setUpClass(cls): cls.testClient = super(TestUserPrivateGateways, cls).getClsTestClient() cls.apiclient = cls.testClient.getApiClient() cls.apiclient = cls.testClient.getApiClient() cls.services = cls.testClient.getParsedTestDataConfig() zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests()) cls.zone = Zone(zone.__dict__) cls.template = get_template(cls.apiclient, cls.zone.id) cls._cleanup = [] cls.logger = logging.getLogger("TestUserPrivateGateways") cls.stream_handler = logging.StreamHandler() cls.logger.setLevel(logging.DEBUG) cls.logger.addHandler(cls.stream_handler) cls.domain = get_domain(cls.apiclient) # Create small service offering cls.service_offering = ServiceOffering.create( cls.apiclient, cls.services["service_offerings"]["small"]) cls._cleanup.append(cls.service_offering) # Create network offering for isolated networks cls.network_offering_isolated = NetworkOffering.create( cls.apiclient, cls.services["network_offering"]) cls.network_offering_isolated.update(cls.apiclient, state='Enabled') cls._cleanup.append(cls.network_offering_isolated) # Create vpc offering cls.vpc_offering = VpcOffering.create( cls.apiclient, cls.services["vpc_offering_multi_lb"]) cls.vpc_offering.update(cls.apiclient, state='Enabled') cls._cleanup.append(cls.vpc_offering) # Create network offering for vpc tiers cls.network_offering_vpc = NetworkOffering.create( cls.apiclient, cls.services["nw_offering_isolated_vpc"], conservemode=False) cls.network_offering_vpc.update(cls.apiclient, state='Enabled') cls._cleanup.append(cls.network_offering_vpc) # Create sub-domain cls.sub_domain = Domain.create(cls.apiclient, cls.services["acl"]["domain1"]) cls._cleanup.append(cls.sub_domain) # Create domain admin and normal user cls.domain_admin = Account.create(cls.apiclient, cls.services["acl"]["accountD1A"], admin=True, domainid=cls.sub_domain.id) cls._cleanup.append(cls.domain_admin) cls.normal_user = Account.create(cls.apiclient, cls.services["acl"]["accountD1B"], domainid=cls.sub_domain.id) cls._cleanup.append(cls.normal_user) # Create project cls.project = Project.create(cls.apiclient, cls.services["project"], account=cls.domain_admin.name, domainid=cls.domain_admin.domainid) cls._cleanup.append(cls.project) # Create api clients for domain admin and normal user cls.domainadmin_user = cls.domain_admin.user[0] cls.domainapiclient = cls.testClient.getUserApiClient( cls.domainadmin_user.username, cls.sub_domain.name) cls.normaluser_user = cls.normal_user.user[0] cls.normaluser_apiclient = cls.testClient.getUserApiClient( cls.normaluser_user.username, cls.sub_domain.name)
def setUpClass(cls): cls.testClient = super(TestVMLifeCycleHostmaintenance, cls).getClsTestClient() cls.api_client = cls.testClient.getApiClient() cls.services = Services().services # Get Zone, Domain and templates cls.domain = get_domain(cls.api_client) cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests()) cls.template = get_template( cls.api_client, cls.zone.id, cls.services["ostype"] ) cls.hypervisor = cls.testClient.getHypervisorInfo() cls.services["virtual_machine"]["zoneid"] = cls.zone.id cls.services["virtual_machine"]["template"] = cls.template.id clusterWithSufficientHosts = None clusters = Cluster.list(cls.api_client, zoneid=cls.zone.id) for cluster in clusters: cls.hosts = Host.list(cls.api_client, clusterid=cluster.id) if len(cls.hosts) >= 2: clusterWithSufficientHosts = cluster break if clusterWithSufficientHosts is None: raise unittest.SkipTest("No Cluster with 2 hosts found") Host.update(cls.api_client, id=cls.hosts[0].id, hosttags="hosttag1") Host.update(cls.api_client, id=cls.hosts[1].id, hosttags="hosttag2") cls.service_offering_1 = ServiceOffering.create( cls.api_client, cls.services["service_offering_1"] ) cls.service_offering_2 = ServiceOffering.create( cls.api_client, cls.services["service_offering_2"] ) cls.vpc_off = VpcOffering.create( cls.api_client, cls.services["vpc_offering"] ) cls.vpc_off.update(cls.api_client, state='Enabled') cls.account = Account.create( cls.api_client, cls.services["account"], admin=True, domainid=cls.domain.id ) cls.vpc_off = VpcOffering.create( cls.api_client, cls.services["vpc_offering"] ) cls.vpc_off.update(cls.api_client, state='Enabled') cls.services["vpc"]["cidr"] = '10.1.1.1/16' cls.vpc = VPC.create( cls.api_client, cls.services["vpc"], vpcofferingid=cls.vpc_off.id, zoneid=cls.zone.id, account=cls.account.name, domainid=cls.account.domainid ) cls.nw_off = NetworkOffering.create( cls.api_client, cls.services["network_offering"], conservemode=False ) # Enable Network offering cls.nw_off.update(cls.api_client, state='Enabled') # Creating network using the network offering created cls.network_1 = Network.create( cls.api_client, cls.services["network"], accountid=cls.account.name, domainid=cls.account.domainid, networkofferingid=cls.nw_off.id, zoneid=cls.zone.id, gateway='10.1.1.1', vpcid=cls.vpc.id ) cls.nw_off_no_lb = NetworkOffering.create( cls.api_client, cls.services["network_offering_no_lb"], conservemode=False ) # Enable Network offering cls.nw_off_no_lb.update(cls.api_client, state='Enabled') # Creating network using the network offering created cls.network_2 = Network.create( cls.api_client, cls.services["network"], accountid=cls.account.name, domainid=cls.account.domainid, networkofferingid=cls.nw_off_no_lb.id, zoneid=cls.zone.id, gateway='10.1.2.1', vpcid=cls.vpc.id ) # Spawn an instance in that network cls.vm_1 = VirtualMachine.create( cls.api_client, cls.services["virtual_machine"], accountid=cls.account.name, domainid=cls.account.domainid, serviceofferingid=cls.service_offering_1.id, networkids=[str(cls.network_1.id)] ) # Spawn an instance in that network cls.vm_2 = VirtualMachine.create( cls.api_client, cls.services["virtual_machine"], accountid=cls.account.name, domainid=cls.account.domainid, serviceofferingid=cls.service_offering_1.id, networkids=[str(cls.network_1.id)] ) cls.vm_3 = VirtualMachine.create( cls.api_client, cls.services["virtual_machine"], accountid=cls.account.name, domainid=cls.account.domainid, serviceofferingid=cls.service_offering_2.id, networkids=[str(cls.network_2.id)] ) routers = Router.list( cls.api_client, account=cls.account.name, domainid=cls.account.domainid, listall=True ) if isinstance(routers, list): cls.vpcvr = routers[0] cls._cleanup = [ cls.service_offering_1, cls.service_offering_2, cls.nw_off, cls.nw_off_no_lb, ] return
def 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.hypervisorSupported = False cls.nfsStorageFound = False cls.localStorageFound = False cls.sharedMountPointFound = False if cls.hypervisor.lower() in ['kvm', 'lxc']: cls.hypervisorSupported = True if cls.hypervisorSupported: 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) storage_pools = StoragePool.list( cls.apiclient, zoneid=cls.zone.id ) for pool in storage_pools: if not cls.nfsStorageFound and pool.type == "NetworkFilesystem": cls.nfsStorageFound = True cls.nfsPoolId = pool.id elif not cls.localStorageFound and pool.type == "Filesystem": cls.localStorageFound = True cls.localPoolId = pool.id elif not cls.sharedMountPointFound and pool.type == "SharedMountPoint": cls.sharedMountPointFound = True cls.sharedPoolId = pool.id cls.nfsKvmNotAvailable = not cls.hypervisorSupported or not cls.nfsStorageFound cls.localStorageKvmNotAvailable = not cls.hypervisorSupported or not cls.localStorageFound cls.sharedMountPointKvmNotAvailable = not cls.hypervisorSupported or not cls.sharedMountPointFound return
def test_19_template_tag(self): """ Test creation, listing and deletion tag on templates """ if self.hypervisor.lower() in ['lxc']: self.skipTest( "template creation from volume feature is not supported on %s" % self.hypervisor.lower()) try: noffering = NetworkOffering.list( self.user_api_client, name="DefaultIsolatedNetworkOfferingWithSourceNatService") vm4network = Network.create(self.user_api_client, self.services["network"], accountid=self.account.name, domainid=self.account.domainid, networkofferingid=noffering[0].id, zoneid=self.zone.id) list_nw_response = Network.list(self.user_api_client, id=vm4network.id) self.assertEqual( isinstance(list_nw_response, list), True, "Check list response returns a valid networks list") vm_1 = VirtualMachine.create( self.user_api_client, self.services["small"], templateid=self.template.id, networkids=vm4network.id, serviceofferingid=self.service_offering.id, accountid=self.account.name, domainid=self.account.domainid, mode=self.services['mode'], startvm="true") time.sleep(600) self.debug("Stopping the virtual machine: %s" % vm_1.name) # Stop virtual machine vm_1.stop(self.user_api_client) except Exception as e: self.fail("Failed to stop VM: %s" % e) timeout = self.services["timeout"] while True: list_volume = Volume.list(self.user_api_client, virtualmachineid=vm_1.id, type='ROOT', listall=True) if isinstance(list_volume, list): break elif timeout == 0: raise Exception("List volumes failed.") time.sleep(5) timeout = timeout - 1 self.volume = list_volume[0] self.debug("Creating template from ROOT disk of virtual machine: %s" % vm_1.name) # Create template from volume template = Template.create(self.user_api_client, self.services["template"], self.volume.id) self.cleanup.append(template) self.debug("Created the template(%s). Now restarting the userVm: %s" % (template.name, vm_1.name)) vm_1.start(self.user_api_client) self.debug("Creating a tag for the template") tag = Tag.create(self.user_api_client, resourceIds=template.id, resourceType='Template', tags={'OS': 'windows8'}) self.debug("Tag created: %s" % tag.__dict__) tags = Tag.list(self.user_api_client, listall=True, resourceType='Template', key='OS', value='windows8') self.assertEqual(isinstance(tags, list), True, "List tags should not return empty response") self.assertEqual(tags[0].value, 'windows8', 'The tag should have original value') Template.list( self.user_api_client, templatefilter=self.services["template"]["templatefilter"], listall=True, key='OS', value='windows8') self.debug("Deleting the created tag..") try: tag.delete(self.user_api_client, resourceIds=template.id, resourceType='Template', tags={'OS': 'windows8'}) except Exception as e: self.fail("Failed to delete the tag - %s" % e) self.debug("Verifying if tag is actually deleted!") tags = Tag.list(self.user_api_client, listall=True, resourceType='Template', key='OS', value='windows8') self.assertEqual(tags, None, "List tags should return empty response") return
def test_16_create_template_volume(self): """Test Create template from volume """ noffering = NetworkOffering.list( self.user_api_client, name="DefaultIsolatedNetworkOfferingWithSourceNatService") vm2network = Network.create(self.user_api_client, self.services["network"], accountid=self.account.name, domainid=self.account.domainid, networkofferingid=noffering[0].id, zoneid=self.zone.id) list_nw_response = Network.list(self.user_api_client, id=vm2network.id) self.assertEqual(isinstance(list_nw_response, list), True, "Check list response returns a valid networks list") templatevm = VirtualMachine.create( self.user_api_client, self.services["small"], templateid=self.template.id, accountid=self.account.name, domainid=self.account.domainid, networkids=vm2network.id, serviceofferingid=self.service_offering.id, mode=self.services['mode'], startvm="true") time.sleep(600) vm_response = VirtualMachine.list(self.user_api_client, id=templatevm.id) self.assertNotEqual(len(vm_response), 0, "Check VMs available in List VMs response") vm = vm_response[0] self.assertEqual(vm.state, 'Running', "Check the state of VM created from Template") templatevm.stop(self.user_api_client, forced="false") vm_response = VirtualMachine.list(self.user_api_client, id=templatevm.id) vm = vm_response[0] self.assertEqual( vm.state, 'Stopped', "Check the state of VM is in Stopped state before creating the Template" ) list_volume_response = Volume.list(self.user_api_client, virtualmachineid=vm.id, type="ROOT", listall=True) #Create template from Virtual machine and Volume ID roottemplate = Template.create( self.user_api_client, self.services["interop"]["template"], volumeid=list_volume_response[0].id, account=self.account.name, domainid=self.domain.id, ) time.sleep(600) list_template_response = Template.list( self.user_api_client, templatefilter=\ self.services["templatefilter"], id=roottemplate.id ) self.assertEqual(isinstance(list_template_response, list), True, "Check list response returns a valid list") #Verify template response to check whether template added successfully self.assertNotEqual(len(list_template_response), 0, "Check template available in List Templates") template_response = list_template_response[0] self.assertEqual(template_response.displaytext, self.services["interop"]["template"]["displaytext"], "Check display text of newly created template") name = template_response.name self.assertEqual( name.count(self.services["interop"]["template"]["name"]), 1, "Check name of newly created template") templatevm.delete(self.apiclient) vm2network.delete(self.user_api_client) vm3network = Network.create(self.user_api_client, self.services["network"], accountid=self.account.name, domainid=self.account.domainid, networkofferingid=noffering[0].id, zoneid=self.zone.id) list_nw_response = Network.list(self.user_api_client, id=vm3network.id) self.assertEqual(isinstance(list_nw_response, list), True, "Check list response returns a valid networks list") templatevm = VirtualMachine.create( self.user_api_client, self.services["small"], templateid=roottemplate.id, networkids=vm3network.id, serviceofferingid=self.service_offering.id, accountid=self.account.name, domainid=self.account.domainid, mode=self.services['mode'], startvm="true") time.sleep(600) vm_response = VirtualMachine.list(self.user_api_client, id=templatevm.id) self.assertNotEqual(len(vm_response), 0, "Check VMs available in List VMs response") vm = vm_response[0] self.assertEqual(vm.state, 'Running', "Check the state of VM created from Template") # Delete the template roottemplate.delete(self.user_api_client) list_template_response = Template.list( self.user_api_client, templatefilter=\ self.services["template"]["templatefilter"], id=roottemplate.id, zoneid=self.zone.id ) self.assertEqual(list_template_response, None, "Check template available in List Templates") templatevm.delete(self.apiclient) vm3network.delete(self.user_api_client) return
def test_16_create_template_volume(self): """Test Create template from volume """ noffering=NetworkOffering.list( self.user_api_client, name="DefaultIsolatedNetworkOfferingWithSourceNatService" ) vm2network=Network.create( self.user_api_client, self.services["network"], accountid=self.account.name, domainid=self.account.domainid, networkofferingid=noffering[0].id, zoneid=self.zone.id ) list_nw_response = Network.list( self.user_api_client, id=vm2network.id ) self.assertEqual( isinstance(list_nw_response, list), True, "Check list response returns a valid networks list" ) templatevm = VirtualMachine.create( self.user_api_client, self.services["small"], templateid=self.template.id, accountid=self.account.name, domainid=self.account.domainid, networkids=vm2network.id, serviceofferingid=self.service_offering.id, mode=self.services['mode'], startvm="true" ) time.sleep(600) vm_response = VirtualMachine.list( self.user_api_client, id=templatevm.id) self.assertNotEqual( len(vm_response), 0, "Check VMs available in List VMs response" ) vm = vm_response[0] self.assertEqual( vm.state, 'Running', "Check the state of VM created from Template" ) templatevm.stop(self.user_api_client,forced="false") vm_response = VirtualMachine.list( self.user_api_client, id=templatevm.id) vm = vm_response[0] self.assertEqual( vm.state, 'Stopped', "Check the state of VM is in Stopped state before creating the Template" ) list_volume_response = Volume.list( self.user_api_client, virtualmachineid=vm.id, type="ROOT", listall=True ) #Create template from Virtual machine and Volume ID roottemplate = Template.create( self.user_api_client, self.services["interop"]["template"], volumeid=list_volume_response[0].id, account=self.account.name, domainid=self.domain.id, ) time.sleep(600) list_template_response = Template.list( self.user_api_client, templatefilter=\ self.services["templatefilter"], id=roottemplate.id ) self.assertEqual( isinstance(list_template_response, list), True, "Check list response returns a valid list" ) #Verify template response to check whether template added successfully self.assertNotEqual( len(list_template_response), 0, "Check template available in List Templates" ) template_response = list_template_response[0] self.assertEqual( template_response.displaytext, self.services["interop"]["template"]["displaytext"], "Check display text of newly created template" ) name = template_response.name self.assertEqual( name.count(self.services["interop"]["template"]["name"]), 1, "Check name of newly created template" ) templatevm.delete(self.apiclient) vm2network.delete(self.user_api_client) vm3network=Network.create( self.user_api_client, self.services["network"], accountid=self.account.name, domainid=self.account.domainid, networkofferingid=noffering[0].id, zoneid=self.zone.id ) list_nw_response = Network.list( self.user_api_client, id=vm3network.id ) self.assertEqual( isinstance(list_nw_response, list), True, "Check list response returns a valid networks list" ) templatevm = VirtualMachine.create( self.user_api_client, self.services["small"], templateid=roottemplate.id, networkids=vm3network.id, serviceofferingid=self.service_offering.id, accountid=self.account.name, domainid=self.account.domainid, mode=self.services['mode'], startvm="true" ) time.sleep(600) vm_response = VirtualMachine.list( self.user_api_client, id=templatevm.id) self.assertNotEqual( len(vm_response), 0, "Check VMs available in List VMs response" ) vm = vm_response[0] self.assertEqual( vm.state, 'Running', "Check the state of VM created from Template" ) # Delete the template roottemplate.delete(self.user_api_client) list_template_response = Template.list( self.user_api_client, templatefilter=\ self.services["template"]["templatefilter"], id=roottemplate.id, zoneid=self.zone.id ) self.assertEqual( list_template_response, None, "Check template available in List Templates" ) templatevm.delete(self.apiclient) vm3network.delete(self.user_api_client) return
def test_15_restore_vm_with_template_id(self): """ Test restoring Virtual Machine with template id """ noffering = NetworkOffering.list( self.user_api_client, name="DefaultIsolatedNetworkOfferingWithSourceNatService") vm1network = Network.create(self.user_api_client, self.services["network"], accountid=self.account.name, domainid=self.account.domainid, networkofferingid=noffering[0].id, zoneid=self.zone.id) list_nw_response = Network.list(self.user_api_client, id=vm1network.id) self.assertEqual(isinstance(list_nw_response, list), True, "Check list response returns a valid networks list") restorevm = VirtualMachine.create( self.user_api_client, self.services["small"], networkids=vm1network.id, accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.service_offering.id, mode=self.services['mode'], startvm="true") time.sleep(600) list_vm_response = VirtualMachine.list(self.user_api_client, id=restorevm.id) self.assertEqual(list_vm_response[0].state, "Running", "Check virtual machine is in running state") custom_disk_offering = DiskOffering.list(self.user_api_client, name="custom") newvolume = Volume.create(self.user_api_client, self.services["volume"], zoneid=self.zone.id, account=self.account.name, domainid=self.domain.id, diskofferingid=custom_disk_offering[0].id, size=1) # Attach volume to VM cmd = attachVolume.attachVolumeCmd() cmd.id = newvolume.id cmd.virtualmachineid = restorevm.id cmd.deviceid = 1 vol1 = self.user_api_client.attachVolume(cmd) cmd = restoreVirtualMachine.restoreVirtualMachineCmd() cmd.virtualmachineid = restorevm.id cmd.templateid = self.xtemplate.id self.user_api_client.restoreVirtualMachine(cmd) time.sleep(600) list_vm_response = VirtualMachine.list(self.user_api_client, id=restorevm.id) self.assertEqual(isinstance(list_vm_response, list), True, "Check list response returns a valid list") self.assertNotEqual(len(list_vm_response), 0, "Check VM available in List Virtual Machines") self.assertEqual(list_vm_response[0].state, "Running", "Check virtual machine is in Stopped state") restorevm.delete(self.apiclient) vm1network.delete(self.user_api_client) return
def test_01_ip_resouce_count_vpc_network(self): """ Test IP count in VPC networks """ self.debug("Creating a VPC offering..") vpc_off = VpcOffering.create(self.apiclient, self.services["vpc_offering"]) self.validate_vpc_offering(vpc_off) self.debug("Enabling the VPC offering created") vpc_off.update(self.apiclient, state='Enabled') self.debug("creating a VPC network in the account: %s" % self.account.name) self.services["vpc"]["cidr"] = '10.1.1.1/16' vpc = VPC.create(self.apiclient, self.services["vpc"], vpcofferingid=vpc_off.id, zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid) self.validate_vpc_network(vpc) nw_off = NetworkOffering.create(self.apiclient, self.services["network_offering"], conservemode=False) # Enable Network offering nw_off.update(self.apiclient, state='Enabled') self._cleanup.append(nw_off) # Creating network using the network offering created self.debug("Creating network with network offering: %s" % nw_off.id) network_1 = Network.create(self.apiclient, self.services["network"], accountid=self.account.name, domainid=self.account.domainid, networkofferingid=nw_off.id, zoneid=self.zone.id, gateway='10.1.1.1', vpcid=vpc.id) self.debug("Created network with ID: %s" % network_1.id) account_list = Account.list(self.apiclient, id=self.account.id) totalip_1 = account_list[0].iptotal self.debug("Total IP: %s" % totalip_1) public_ip_1 = self.acquire_publicip(network_1, vpc) public_ip_2 = self.acquire_publicip(network_1, vpc) public_ip_3 = self.acquire_publicip(network_1, vpc) account_list = Account.list(self.apiclient, id=self.account.id) totalip = account_list[0].iptotal self.debug("Total IP: %s" % totalip) self.assertTrue(totalip - totalip_1 == 3, "publicip count is 3") self.updateIPCount() account_list = Account.list(self.apiclient, id=self.account.id) totalip = account_list[0].iptotal self.assertTrue(totalip - totalip_1 == 3, "publicip count is 3")
def 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.nicira_shared_network_iprange = cls.config.niciraNvp.shared_network.iprange cls.l2gatewayserviceuuid = cls.config.niciraNvp.shared_network.l2gatewayserviceuuid cls.physical_network_id = cls.get_nicira_enabled_physical_network_id( cls.physical_networks) cls.network_offerring_services = [{ 'name': 'NiciraEnabledIsolatedNetwork', 'displaytext': 'NiciraEnabledIsolatedNetwork', 'guestiptype': 'Isolated', 'supportedservices': 'SourceNat,Dhcp,Dns,Firewall,PortForwarding,Connectivity', 'traffictype': 'GUEST', 'availability': 'Optional', 'serviceProviderList': { 'SourceNat': 'VirtualRouter', 'Dhcp': 'VirtualRouter', 'Dns': 'VirtualRouter', 'Firewall': 'VirtualRouter', 'PortForwarding': 'VirtualRouter', 'Connectivity': 'NiciraNvp' } }, { 'name': 'NiciraEnabledSharedNetwork', 'displaytext': 'NiciraEnabledSharedNetwork', 'guestiptype': 'Shared', 'supportedservices': 'Connectivity,Dhcp,UserData,SourceNat,StaticNat,Lb,PortForwarding', 'traffictype': 'GUEST', 'availability': 'Optional', 'specifyVlan': 'true', 'specifyIpRanges': 'true', 'serviceProviderList': { 'Connectivity': 'NiciraNvp', 'Dhcp': 'VirtualRouter', 'SourceNat': 'VirtualRouter', 'StaticNat': 'VirtualRouter', 'Lb': 'VirtualRouter', 'PortForwarding': 'VirtualRouter', 'UserData': 'VirtualRouter' } }] cls.network_offering_isolated = NetworkOffering.create( cls.api_client, cls.network_offerring_services[0]) cls.network_offering_isolated.update(cls.api_client, state='Enabled') cls.network_offering_shared = NetworkOffering.create( cls.api_client, cls.network_offerring_services[1]) cls.network_offering_shared.update(cls.api_client, state='Enabled') cls.nicira_credentials = {'username': '******', 'password': '******'} cls.nicira_primary_controller = cls.determine_primary_controller( cls.nicira_hosts, cls.nicira_credentials) cls.transport_zone_uuid = cls.get_transport_zone_from_controller( cls.nicira_primary_controller, cls.nicira_credentials) cls.admin_account = 'admin' cls.admin_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, 'offerha': 'true' } } } 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_isolated, cls.service_offering, cls.network_offering_shared ] cls.logger = logging.getLogger('TestNiciraContoller') cls.stream_handler = logging.StreamHandler() cls.logger.setLevel(logging.DEBUG) cls.logger.addHandler(cls.stream_handler)
def setUpClass(cls): cls.testClient = super(TestPublicIp, cls).getClsTestClient() cls.apiclient = cls.testClient.getApiClient() cls.services = cls.testClient.getParsedTestDataConfig() # Get Zone, Domain and templates cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests()) cls.services['mode'] = cls.zone.networktype cls.logger = logging.getLogger("TestPublicIp") cls.domain = get_domain(cls.apiclient) cls.services["virtual_machine"]["zoneid"] = cls.zone.id cls.template = get_template( cls.apiclient, cls.zone.id, cls.services["ostype"] ) cls.use_system_ips_config_name = "use.system.public.ips" cls.use_system_ips_config = Configurations.list( cls.apiclient, name=cls.use_system_ips_config_name ) cls.use_system_ips_config_value = cls.use_system_ips_config[0].value Configurations.update( cls.apiclient, name=cls.use_system_ips_config_name, value="false" ) cls._cleanup = [] cls.unsupportedHypervisor = False cls.hypervisor = cls.testClient.getHypervisorInfo() if cls.hypervisor.lower() in ['lxc']: cls.unsupportedHypervisor = True return # Create new domain1 cls.domain1 = Domain.create( cls.apiclient, services=cls.services["acl"]["domain1"], parentdomainid=cls.domain.id) # Create account1 cls.account1 = Account.create( cls.apiclient, cls.services["account"], # cls.services["acl"]["accountD1"], admin=True, domainid=cls.domain1.id ) # Create new sub-domain cls.sub_domain = Domain.create( cls.apiclient, services=cls.services["acl"]["domain11"], parentdomainid=cls.domain1.id) # Create account for sub-domain cls.sub_account = Account.create( cls.apiclient, cls.services["acl"]["accountD11"], domainid=cls.sub_domain.id ) # Create new domain2 cls.domain2 = Domain.create( cls.apiclient, services=cls.services["acl"]["domain2"], parentdomainid=cls.domain.id) # Create account2 cls.account2 = Account.create( cls.apiclient, cls.services["acl"]["accountD2"], domainid=cls.domain2.id ) cls.services["publiciprange"]["zoneid"] = cls.zone.id cls.services["publiciprange"]["forvirtualnetwork"] = "true" # Create public ip range 1 cls.services["publiciprange"]["vlan"] = get_free_vlan( cls.apiclient, cls.zone.id)[1] random_subnet_number = random.randrange(10,20) cls.services["publiciprange"]["gateway"] = "10.100." + \ str(random_subnet_number) + ".254" cls.services["publiciprange"]["startip"] = "10.100." + \ str(random_subnet_number) + ".1" cls.services["publiciprange"]["endip"] = "10.100." + \ str(random_subnet_number) + ".10" cls.services["publiciprange"]["netmask"] = "255.255.255.0" cls.public_ip_range1 = PublicIpRange.create( cls.apiclient, cls.services["publiciprange"], account=cls.account1.name, domainid=cls.account1.domainid ) # dedicate ip range to sub domain cls.services["publiciprange"]["vlan"] = get_free_vlan( cls.apiclient, cls.zone.id)[1] random_subnet_number = random.randrange(10,20) cls.services["publiciprange"]["gateway"] = "10.110." + \ str(random_subnet_number) + ".254" cls.services["publiciprange"]["startip"] = "10.110." + \ str(random_subnet_number) + ".1" cls.services["publiciprange"]["endip"] = "10.110." + \ str(random_subnet_number) + ".10" cls.services["publiciprange"]["netmask"] = "255.255.255.0" cls.public_ip_range2 = PublicIpRange.create( cls.apiclient, cls.services["publiciprange"], account=cls.sub_account.name, domainid=cls.sub_account.domainid ) # dedicate ip range to second domain cls.services["publiciprange"]["vlan"] = get_free_vlan( cls.apiclient, cls.zone.id)[1] random_subnet_number = random.randrange(10,20) cls.services["publiciprange"]["gateway"] = "10.120." + \ str(random_subnet_number) + ".254" cls.services["publiciprange"]["startip"] = "10.120." + \ str(random_subnet_number) + ".1" cls.services["publiciprange"]["endip"] = "10.120." + \ str(random_subnet_number) + ".10" cls.services["publiciprange"]["netmask"] = "255.255.255.0" cls.public_ip_range3 = PublicIpRange.create( cls.apiclient, cls.services["publiciprange"], account=cls.account2.name, domainid=cls.account2.domainid ) # create vpc offering and VPC cls.vpc_off = VpcOffering.create( cls.apiclient, cls.services["vpc_offering"] ) cls.vpc_off.update(cls.apiclient, state='Enabled') # create network offering cls.isolated_network_offering = NetworkOffering.create( cls.apiclient, cls.services["isolated_network_offering"], conservemode=False ) NetworkOffering.update( cls.isolated_network_offering, cls.apiclient, id=cls.isolated_network_offering.id, state="enabled" ) physical_network, shared_vlan = get_free_vlan( cls.apiclient, cls.zone.id) if shared_vlan is None: cls.fail("Failed to get free vlan id for shared network") 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 ) NetworkOffering.update( cls.shared_network_offering, cls.apiclient, id=cls.shared_network_offering.id, state="enabled" ) # create network using the shared network offering created cls.services["shared_network"]["acltype"] = "Domain" cls.services["shared_network"][ "networkofferingid"] = cls.shared_network_offering.id cls.services["shared_network"][ "physicalnetworkid"] = physical_network.id cls.services["shared_network"]["vlan"] = shared_vlan shared_network_subnet_number = random.randrange(1, 254) cls.services["shared_network"]["netmask"] = "255.255.255.0" cls.services["shared_network"]["gateway"] = "172.16." + \ str(shared_network_subnet_number) + ".254" cls.services["shared_network"]["startip"] = "172.16." + \ str(shared_network_subnet_number) + ".1" cls.services["shared_network"]["endip"] = "172.16." + \ str(shared_network_subnet_number) + ".10" cls.guest_network = Network.create( cls.apiclient, cls.services["shared_network"], networkofferingid=cls.shared_network_offering.id, zoneid=cls.zone.id ) cls._cleanup.append(cls.guest_network) cls._cleanup.append(cls.shared_network_offering) cls._cleanup.append(cls.account1) cls._cleanup.append(cls.account2) cls._cleanup.append(cls.sub_account) cls._cleanup.append(cls.sub_domain) cls._cleanup.append(cls.domain1) cls._cleanup.append(cls.domain2) cls._cleanup.append(cls.public_ip_range1) cls._cleanup.append(cls.public_ip_range2) cls._cleanup.append(cls.public_ip_range3)
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_01_RVR_Network_FW_PF_SSH_default_routes_egress_true(self): """ Test redundant router internals """ self.logger.debug("Starting test_01_RVR_Network_FW_PF_SSH_default_routes_egress_true...") self.logger.debug("Creating Network Offering with default egress TRUE") network_offering_egress_true = NetworkOffering.create( self.apiclient, self.services["nw_off_persistent_RVR_egress_true"], conservemode=True ) network_offering_egress_true.update(self.api_client, state='Enabled') self.logger.debug("Creating network with network offering: %s" % network_offering_egress_true.id) network = Network.create( self.apiclient, self.services["network"], accountid=self.account.name, domainid=self.account.domainid, networkofferingid=network_offering_egress_true.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_true) 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 ) public_ip = public_ips[0] self.assertEqual( isinstance(public_ips, list), True, "Check for list public IPs response return valid data" ) 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 ) # Test SSH after closing port 22 expected = 1 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 be successful!" ) 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!" ) 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 = 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 once rule is added!" ) 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 test_01_isolate_network_FW_PF_default_routes_egress_true(self): """ Test redundant router internals """ self.logger.debug("Starting test_01_isolate_network_FW_PF_default_routes_egress_true...") self.logger.debug("Creating Network Offering with default egress TRUE") network_offering_egress_true = NetworkOffering.create(self.apiclient, self.services["network_offering_egress_true"], conservemode=True) network_offering_egress_true.update(self.apiclient, state='Enabled') self.logger.debug("Creating Network with Network Offering ID %s" % network_offering_egress_true.id) network = Network.create(self.apiclient, self.services["network"], accountid=self.account.name, domainid=self.account.domainid, networkofferingid=network_offering_egress_true.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_true) 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" ) # Test SSH after closing port 22 expected = 1 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 be successful!" ) 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!" ) 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 = 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 once rule is added!" ) return
def test_01_create_network_without_start_end_ip(self): """Create Shared network without start and end ip Steps: # 1. Update the global setting allow.empty.start.end.ipaddress to true # 2. Create a shared network without specifying start or end ip # 3. This should create the network # 4. Now Update the global setting allow.empty.start.end.ipaddress to false # 5. Create a shared network without specifying start or end ip # 6. Exception should be thrown since start and end ip are not specified :return: """ # Create network offering self.network_offering = NetworkOffering.create( self.apiclient, self.testdata["network_offering_shared"]) NetworkOffering.update(self.network_offering, self.apiclient, id=self.network_offering.id, state="enabled") physical_network, vlan = get_free_vlan(self.apiclient, self.zone.id) self.testdata["shared_network_sg"][ "physicalnetworkid"] = physical_network.id random_subnet_number = random.randrange(100, 199) self.testdata["shared_network_sg"]["specifyVlan"] = 'True' self.testdata["shared_network_sg"]["specifyIpRanges"] = 'True' self.testdata["shared_network_sg"][ "name"] = "Shared-Network-SG-Test-vlan" + str(random_subnet_number) self.testdata["shared_network_sg"][ "displaytext"] = "Shared-Network-SG-Test-vlan" + str( random_subnet_number) self.testdata["shared_network_sg"]["vlan"] = "vlan://" + str( random_subnet_number) self.testdata["shared_network_sg"]["startip"] = None self.testdata["shared_network_sg"]["endip"] = None self.testdata["shared_network_sg"]["gateway"] = "192.168." + str( random_subnet_number) + ".254" self.testdata["shared_network_sg"]["netmask"] = "255.255.255.0" self.testdata["shared_network_sg"]["acltype"] = "account" # Update the global setting to true Configurations.update(self.apiclient, name="allow.empty.start.end.ipaddress", value="true") # Create network network = Network.create(self.apiclient, self.testdata["shared_network_sg"], networkofferingid=self.network_offering.id, zoneid=self.zone.id, accountid=self.account.name, domainid=self.account.domainid) self.logger.info("network id is %s" % network.id) self.cleanup.append(network) # Update the global setting to false Configurations.update(self.apiclient, name="allow.empty.start.end.ipaddress", value="false") # Exception should be thrown with self.assertRaises(Exception): self.testdata["shared_network_sg"]["vlan"] = "vlan://" + str( random_subnet_number) network2 = Network.create( self.apiclient, self.testdata["shared_network_sg"], networkofferingid=self.network_offering.id, zoneid=self.zone.id, accountid=self.account.name, domainid=self.account.domainid) # Restore the setting to default value which is true Configurations.update(self.apiclient, name="allow.empty.start.end.ipaddress", value="true") self.cleanup.append(self.network_offering)
def setUp(self): self.cleanup = [] 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": raise unittest.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 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 test_01_create_delete_portforwarding_fornonvpc(self): """ @summary: Test to list, create and delete Port Forwarding for IP Address associated to Non VPC network @Steps: Step1: Creating a Network for the user Step2: Associating an IP Addresses for Network Step3: Launching Virtual Machine in network created in step 2 Step4: Listing Port Forwarding Rules for the IP Address associated in Step2 Step5: Verifying that no Port Forwarding Rules are listed Step6: Creating a Port Forwarding Rule for IP Address associated in Step2 Step7: Listing Port Forwarding Rules for the IP Address associated in Step2 Step8: Verifying 1 Port Forwarding Rule is listed Step9: Deleting the Port Forwarding Rule created in Step6 Step10: Listing Port Forwarding Rules for the IP Address associated in Step2 Step11: Verifying that no Port Forwarding Rules are listed """ # Listing all the Networks's for a user list_networks_before = Network.list( self.userapiclient, listall=self.services["listall"], type="Isolated" ) # Verifying No Networks are listed self.assertIsNone( list_networks_before, "Networks listed for newly created User" ) # Listing Network Offerings network_offerings_list = NetworkOffering.list( self.apiClient, forvpc="false", guestiptype="Isolated", state="Enabled", supportedservices="SourceNat,PortForwarding", zoneid=self.zone.id ) status = validateList(network_offerings_list) self.assertEquals( PASS, status[0], "Isolated Network Offerings with sourceNat,\ PortForwarding enabled are not found" ) # Creating a network network = Network.create( self.userapiclient, self.services["network"], accountid=self.account.name, domainid=self.domain.id, networkofferingid=network_offerings_list[0].id, zoneid=self.zone.id ) self.assertIsNotNone( network, "Network creation failed" ) # Listing all the IP Addresses for a user list_ipaddresses_before = PublicIPAddress.list( self.userapiclient, listall=self.services["listall"] ) # Verifying no IP Addresses are listed self.assertIsNone( list_ipaddresses_before, "IP Addresses listed for newly created User" ) # Associating an IP Addresses to Network created associated_ipaddress = PublicIPAddress.create( self.userapiclient, services=self.services["network"], networkid=network.id ) self.assertIsNotNone( associated_ipaddress, "Failed to Associate IP Address" ) # Listing all the IP Addresses for a user list_ipaddresses_after = PublicIPAddress.list( self.userapiclient, listall=self.services["listall"] ) status = validateList(list_ipaddresses_after) self.assertEquals( PASS, status[0], "IP Addresses Association Failed" ) # Verifying the length of the list is 1 self.assertEqual( 1, len(list_ipaddresses_after), "Number of IP Addresses associated are not matching expected" ) # Launching a Virtual Machine with above created Network vm_created = VirtualMachine.create( self.userapiclient, self.services["virtual_machine"], accountid=self.account.name, domainid=self.account.domainid, networkids=network.id, serviceofferingid=self.service_offering.id, ) self.assertIsNotNone( vm_created, "Failed to launch a VM under network created" ) self.cleanup.append(network) # Listing Virtual Machines in running state in above created network list_vms_running = VirtualMachine.list( self.userapiclient, listall=self.services["listall"], state="Running", networkid=network.id ) status = validateList(list_vms_running) self.assertEquals( PASS, status[0], "VM Created is not in Running state" ) # Verifying the length of the list is 1 self.assertEqual( 1, len(list_ipaddresses_after), "VM Created is not in Running state" ) self.assertEquals( vm_created.id, list_vms_running[0].id, "VM Created is not in Running state" ) # Listing Virtual Machines in stopped state in above created network list_vms_stopped = VirtualMachine.list( self.userapiclient, listall=self.services["listall"], state="Stopped", networkid=network.id ) # Verifying no VMs are in stopped state self.assertIsNone( list_vms_stopped, "VM Created is in stopped state" ) # Listing Port Forwarding Rules for the IP Address associated list_prtfwdrule_before = NATRule.list( self.userapiclient, listall=self.services["listall"], ipaddressid=associated_ipaddress.ipaddress.id ) # Verifying no port forwarding rules are listed self.assertIsNone( list_prtfwdrule_before, "Port Forwarding Rules listed for newly associated IP Address" ) # Creating a Port Forwarding rule portfwd_rule = NATRule.create( self.userapiclient, virtual_machine=vm_created, services=self.services["natrule"], ipaddressid=associated_ipaddress.ipaddress.id, ) self.assertIsNotNone( portfwd_rule, "Failed to create Port Forwarding Rule" ) # Verifying details of Sticky Policy created # Creating expected and actual values dictionaries expected_dict = { "ipaddressid": associated_ipaddress.ipaddress.id, "privateport": str(self.services["natrule"]["privateport"]), "publicport": str(self.services["natrule"]["publicport"]), "protocol": str(self.services["natrule"]["protocol"]).lower(), } actual_dict = { "ipaddressid": portfwd_rule.ipaddressid, "privateport": str(portfwd_rule.privateport), "publicport": str(portfwd_rule.publicport), "protocol": portfwd_rule.protocol, } portfwd_status = self.__verify_values( expected_dict, actual_dict ) self.assertEqual( True, portfwd_status, "Created Port Forward Rule details are not as expected" ) # Listing Port Forwarding Rules for the IP Address associated list_prtfwdrule_after = NATRule.list( self.userapiclient, listall=self.services["listall"], ipaddressid=associated_ipaddress.ipaddress.id ) status = validateList(list_prtfwdrule_after) self.assertEquals( PASS, status[0], "Failed to create Port Forwarding Rule" ) # Verifying the length of the list is 1 self.assertEqual( 1, len(list_prtfwdrule_after), "Failed to create Port Forwarding Rule" ) # Deleting Port Forwarding Rule portfwd_rule.delete(self.userapiclient) # Creating a Port Forwarding rule with port range portfwd_rule = NATRule.create( self.userapiclient, virtual_machine=vm_created, services=self.services["natrulerange"], ipaddressid=associated_ipaddress.ipaddress.id, ) self.assertIsNotNone( portfwd_rule, "Failed to create Port Forwarding Rule" ) #update the private port for port forwarding rule updatefwd_rule = portfwd_rule.update(self.userapiclient, portfwd_rule.id, virtual_machine=vm_created, services=self.services["updatenatrulerange"], ) # Verifying details of Sticky Policy created # Creating expected and actual values dictionaries expected_dict = { "privateport": str(self.services["updatenatrulerange"]["privateport"]), "privateendport": str(self.services["updatenatrulerange"]["privateendport"]), } actual_dict = { "privateport": str(updatefwd_rule.privateport), "privateendport": str(updatefwd_rule.privateendport), } portfwd_status = self.__verify_values( expected_dict, actual_dict ) self.assertEqual( True, portfwd_status, "Updated Port Forward Rule details are not as expected" ) # Deleting Port Forwarding Rule portfwd_rule.delete(self.userapiclient) # Listing Port Forwarding Rules for the IP Address associated list_prtfwdrule_after = NATRule.list( self.userapiclient, listall=self.services["listall"], ipaddressid=associated_ipaddress.ipaddress.id ) # Verifying no port forwarding rules are listed self.assertIsNone( list_prtfwdrule_after, "Port Forwarding Rules listed after deletion" ) # Destroying the VM Launched vm_created.delete(self.apiClient) self.cleanup.append(self.account) return
def test_01_acquire_public_ips_in_isolated_network_with_single_vr(self): """ Acquire IPs in multiple subnets in isolated networks with single VR # Steps # 1. Create network offering with single VR, and enable it # 2. create isolated network with the network offering # 3. create a vm in the network. # verify the available nics in VR should be "eth0,eth1,eth2" # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP # 4. get a free public ip, assign to network, and create port forwarding rules (ssh) to the vm # verify the available nics in VR should be "eth0,eth1,eth2" # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP and new ip # 5. remove the port forwarding rule, and release the new ip # verify the available nics in VR should be "eth0,eth1,eth2" # verify the IPs in VR. eth0 -> guest nic IP, eth2 -> source nat IP # 6. create new public ip range 1 # 7. get a free ip 4 in new ip range 2, assign to network, and enable static nat to vm # verify the available nics in VR should be "eth0,eth1,eth2,eth3" # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 1 # 8. get a free ip in new ip range, assign to network, and create port forwarding rules (ssh) to the vm # verify the available nics in VR should be "eth0,eth1,eth2,eth3" # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 1, new ip 2, # 9. get a free ip in new ip range, assign to network, and create port forwarding rules (ssh) to the vm # verify the available nics in VR should be "eth0,eth1,eth2,eth3" # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 1, new ip 2, new ip 3 # 10. release new ip 2 # verify the available nics in VR should be "eth0,eth1,eth2,eth3" # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 1, new ip 3 # 11. release new ip 1 # verify the available nics in VR should be "eth0,eth1,eth2,eth3" # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 3 # 12. create new public ip range 2 # 13. get a free ip 4 in new ip range 2, assign to network, and create port forwarding rules (ssh) to the vm # verify the available nics in VR should be "eth0,eth1,eth2,eth3,eth4," # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 3, eth4 -> new ip 4 # 14. get a free ip 5 in new ip range 2, assign to network, and create port forwarding rules (ssh) to the vm # verify the available nics in VR should be "eth0,eth1,eth2,eth3,eth4," # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 3, eth4 -> new ip 4/5 # 15. get a free ip 6 in new ip range 2, assign to network, and create port forwarding rules (ssh) to the vm # verify the available nics in VR should be "eth0,eth1,eth2,eth3,eth4," # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 3, eth4 -> new ip 4/5/6 # 16. release new ip 5 # verify the available nics in VR should be "eth0,eth1,eth2,eth3,eth4," # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 3, eth4 -> new ip 4/6 # 17. release new ip 4 # verify the available nics in VR should be "eth0,eth1,eth2,eth3,eth4," # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 3, eth4 -> new ip 6 # 18. release new ip 3 # verify the available nics in VR should be "eth0,eth1,eth2,eth4," # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth4 -> new ip 6 # 19. restart network # verify the available nics in VR should be "eth0,eth1,eth2,eth4," # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth4 -> new ip 6 # 20. reboot router # verify the available nics in VR should be "eth0,eth1,eth2,eth3," # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 6 # 21. restart network with cleanup # verify the available nics in VR should be "eth0,eth1,eth2,eth3," # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 6 # 22. restart network with cleanup, makeredundant=true # verify the available nics in VR should be "eth0,eth1,eth2,eth3," # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 6 """ # Create new domain1 self.domain1 = Domain.create(self.apiclient, services=self.services["acl"]["domain1"], parentdomainid=self.domain.id) # Create account1 self.account1 = Account.create(self.apiclient, self.services["acl"]["accountD1"], domainid=self.domain1.id) self.cleanup.append(self.account1) self.cleanup.append(self.domain1) # 1. Create network offering with single VR, and enable it self.network_offering = NetworkOffering.create( self.apiclient, self.services["isolated_network_offering"], ) self.network_offering.update(self.apiclient, state='Enabled') self.cleanup.append(self.network_offering) # 2. create isolated network with the network offering self.services["network"]["zoneid"] = self.zone.id self.services["network"]["networkoffering"] = self.network_offering.id self.network1 = Network.create(self.apiclient, self.services["network"], self.account1.name, self.account1.domainid) # 3. create a vm in the network. try: self.virtual_machine1 = VirtualMachine.create( self.apiclient, self.services["virtual_machine"], accountid=self.account1.name, domainid=self.account1.domainid, serviceofferingid=self.service_offering.id, templateid=self.template.id, zoneid=self.zone.id, networkids=self.network1.id) except Exception as e: self.fail("Exception while deploying virtual machine: %s" % e) # verify the available nics in VR should be "eth0,eth1,eth2" # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP routers = self.get_routers(self.network1.id) for router in routers: host = self.get_router_host(router) self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,") guestIp, controlIp, sourcenatIp = self.get_router_ips(router) self.verify_ip_address_in_router(router, host, guestIp, "eth0", True) self.verify_ip_address_in_router(router, host, controlIp, "eth1", True) self.verify_ip_address_in_router(router, host, sourcenatIp, "eth2", True) self.verify_router_publicnic_state(router, host, "eth2") # 4. get a free public ip, assign to network, and create port forwarding rules (ssh) to the vm ipaddress = PublicIPAddress.create( self.apiclient, zoneid=self.zone.id, networkid=self.network1.id, ) nat_rule = NATRule.create(self.apiclient, self.virtual_machine1, self.services["natrule"], ipaddressid=ipaddress.ipaddress.id, openfirewall=True) # verify the available nics in VR should be "eth0,eth1,eth2" # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP/new ip routers = self.get_routers(self.network1.id) for router in routers: host = self.get_router_host(router) self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,") guestIp, controlIp, sourcenatIp = self.get_router_ips(router) self.verify_ip_address_in_router(router, host, guestIp, "eth0", True) self.verify_ip_address_in_router(router, host, controlIp, "eth1", True) self.verify_ip_address_in_router(router, host, sourcenatIp, "eth2", True) self.verify_ip_address_in_router(router, host, ipaddress.ipaddress.ipaddress, "eth2", True) self.verify_router_publicnic_state(router, host, "eth2") # 5. release the new ip ipaddress.delete(self.apiclient) # verify the available nics in VR should be "eth0,eth1,eth2" # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP routers = self.get_routers(self.network1.id) for router in routers: host = self.get_router_host(router) self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,") guestIp, controlIp, sourcenatIp = self.get_router_ips(router) self.verify_ip_address_in_router(router, host, guestIp, "eth0", True) self.verify_ip_address_in_router(router, host, controlIp, "eth1", True) self.verify_ip_address_in_router(router, host, sourcenatIp, "eth2", True) self.verify_ip_address_in_router(router, host, ipaddress.ipaddress.ipaddress, "eth2", False) self.verify_router_publicnic_state(router, host, "eth2") # 6. create new public ip range 1 self.services["publiciprange"]["zoneid"] = self.zone.id self.services["publiciprange"]["forvirtualnetwork"] = "true" random_subnet_number = random.randrange(10, 50) self.services["publiciprange"]["vlan"] = get_free_vlan( self.apiclient, self.zone.id)[1] self.services["publiciprange"]["gateway"] = "172.16." + str( random_subnet_number) + ".1" self.services["publiciprange"]["startip"] = "172.16." + str( random_subnet_number) + ".2" self.services["publiciprange"]["endip"] = "172.16." + str( random_subnet_number) + ".10" self.services["publiciprange"]["netmask"] = "255.255.255.0" self.public_ip_range1 = PublicIpRange.create( self.apiclient, self.services["publiciprange"]) self.cleanup.append(self.public_ip_range1) # 7. get a free ip 4 in new ip range 2, assign to network, and enable static nat to vm ip_address_1 = self.get_free_ipaddress(self.public_ip_range1.vlan.id) ipaddress_1 = PublicIPAddress.create(self.apiclient, zoneid=self.zone.id, networkid=self.network1.id, ipaddress=ip_address_1) StaticNATRule.enable(self.apiclient, virtualmachineid=self.virtual_machine1.id, ipaddressid=ipaddress_1.ipaddress.id, networkid=self.network1.id) # verify the available nics in VR should be "eth0,eth1,eth2,eth3" # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 1 routers = self.get_routers(self.network1.id) for router in routers: host = self.get_router_host(router) self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth3,") guestIp, controlIp, sourcenatIp = self.get_router_ips(router) self.verify_ip_address_in_router(router, host, guestIp, "eth0", True) self.verify_ip_address_in_router(router, host, controlIp, "eth1", True) self.verify_ip_address_in_router(router, host, sourcenatIp, "eth2", True) self.verify_ip_address_in_router(router, host, ipaddress_1.ipaddress.ipaddress, "eth3", True) self.verify_router_publicnic_state(router, host, "eth2|eth3") # 8. get a free ip in new ip range, assign to network, and create port forwarding rules (ssh) to the vm # verify the available nics in VR should be "eth0,eth1,eth2,eth3" # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 1, new ip 2, ip_address_2 = self.get_free_ipaddress(self.public_ip_range1.vlan.id) ipaddress_2 = PublicIPAddress.create(self.apiclient, zoneid=self.zone.id, networkid=self.network1.id, ipaddress=ip_address_2) nat_rule = NATRule.create(self.apiclient, self.virtual_machine1, self.services["natrule"], ipaddressid=ipaddress_2.ipaddress.id, openfirewall=True) routers = self.get_routers(self.network1.id) for router in routers: host = self.get_router_host(router) self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth3,") guestIp, controlIp, sourcenatIp = self.get_router_ips(router) self.verify_ip_address_in_router(router, host, guestIp, "eth0", True) self.verify_ip_address_in_router(router, host, controlIp, "eth1", True) self.verify_ip_address_in_router(router, host, sourcenatIp, "eth2", True) self.verify_ip_address_in_router(router, host, ipaddress_1.ipaddress.ipaddress, "eth3", True) self.verify_ip_address_in_router(router, host, ipaddress_2.ipaddress.ipaddress, "eth3", True) self.verify_router_publicnic_state(router, host, "eth2|eth3") # 9. get a free ip in new ip range, assign to network, and create port forwarding rules (ssh) to the vm # verify the available nics in VR should be "eth0,eth1,eth2,eth3" # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 1, new ip 2, new ip 3 ip_address_3 = self.get_free_ipaddress(self.public_ip_range1.vlan.id) ipaddress_3 = PublicIPAddress.create(self.apiclient, zoneid=self.zone.id, networkid=self.network1.id, ipaddress=ip_address_3) nat_rule = NATRule.create(self.apiclient, self.virtual_machine1, self.services["natrule"], ipaddressid=ipaddress_3.ipaddress.id, openfirewall=True) routers = self.get_routers(self.network1.id) for router in routers: host = self.get_router_host(router) self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth3,") guestIp, controlIp, sourcenatIp = self.get_router_ips(router) self.verify_ip_address_in_router(router, host, guestIp, "eth0", True) self.verify_ip_address_in_router(router, host, controlIp, "eth1", True) self.verify_ip_address_in_router(router, host, sourcenatIp, "eth2", True) self.verify_ip_address_in_router(router, host, ipaddress_1.ipaddress.ipaddress, "eth3", True) self.verify_ip_address_in_router(router, host, ipaddress_2.ipaddress.ipaddress, "eth3", True) self.verify_ip_address_in_router(router, host, ipaddress_3.ipaddress.ipaddress, "eth3", True) self.verify_router_publicnic_state(router, host, "eth2|eth3") # 10. release new ip 2 # verify the available nics in VR should be "eth0,eth1,eth2,eth3" # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 1, new ip 3 ipaddress_2.delete(self.apiclient) routers = self.get_routers(self.network1.id) for router in routers: host = self.get_router_host(router) self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth3,") guestIp, controlIp, sourcenatIp = self.get_router_ips(router) self.verify_ip_address_in_router(router, host, guestIp, "eth0", True) self.verify_ip_address_in_router(router, host, controlIp, "eth1", True) self.verify_ip_address_in_router(router, host, sourcenatIp, "eth2", True) self.verify_ip_address_in_router(router, host, ipaddress_1.ipaddress.ipaddress, "eth3", True) self.verify_ip_address_in_router(router, host, ipaddress_2.ipaddress.ipaddress, "eth3", False) self.verify_ip_address_in_router(router, host, ipaddress_3.ipaddress.ipaddress, "eth3", True) self.verify_router_publicnic_state(router, host, "eth2|eth3") # 11. release new ip 1 # verify the available nics in VR should be "eth0,eth1,eth2,eth3" # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 3 ipaddress_1.delete(self.apiclient) routers = self.get_routers(self.network1.id) for router in routers: host = self.get_router_host(router) self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth3,") guestIp, controlIp, sourcenatIp = self.get_router_ips(router) self.verify_ip_address_in_router(router, host, guestIp, "eth0", True) self.verify_ip_address_in_router(router, host, controlIp, "eth1", True) self.verify_ip_address_in_router(router, host, sourcenatIp, "eth2", True) self.verify_ip_address_in_router(router, host, ipaddress_1.ipaddress.ipaddress, "eth3", False) self.verify_ip_address_in_router(router, host, ipaddress_2.ipaddress.ipaddress, "eth3", False) self.verify_ip_address_in_router(router, host, ipaddress_3.ipaddress.ipaddress, "eth3", True) self.verify_router_publicnic_state(router, host, "eth2|eth3") # 12. create new public ip range 2 self.services["publiciprange"]["zoneid"] = self.zone.id self.services["publiciprange"]["forvirtualnetwork"] = "true" self.services["publiciprange"]["vlan"] = get_free_vlan( self.apiclient, self.zone.id)[1] self.services["publiciprange"]["gateway"] = "172.16." + str( random_subnet_number + 1) + ".1" self.services["publiciprange"]["startip"] = "172.16." + str( random_subnet_number + 1) + ".2" self.services["publiciprange"]["endip"] = "172.16." + str( random_subnet_number + 1) + ".10" self.services["publiciprange"]["netmask"] = "255.255.255.0" self.public_ip_range2 = PublicIpRange.create( self.apiclient, self.services["publiciprange"]) self.cleanup.append(self.public_ip_range2) # 13. get a free ip 4 in new ip range 2, assign to network, and create port forwarding rules (ssh) to the vm # verify the available nics in VR should be "eth0,eth1,eth2,eth3,eth4," # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 3, eth4 -> new ip 4 ip_address_4 = self.get_free_ipaddress(self.public_ip_range2.vlan.id) ipaddress_4 = PublicIPAddress.create(self.apiclient, zoneid=self.zone.id, networkid=self.network1.id, ipaddress=ip_address_4) StaticNATRule.enable(self.apiclient, virtualmachineid=self.virtual_machine1.id, ipaddressid=ipaddress_4.ipaddress.id, networkid=self.network1.id) routers = self.get_routers(self.network1.id) for router in routers: host = self.get_router_host(router) self.verify_network_interfaces_in_router( router, host, "eth0,eth1,eth2,eth3,eth4,") guestIp, controlIp, sourcenatIp = self.get_router_ips(router) self.verify_ip_address_in_router(router, host, guestIp, "eth0", True) self.verify_ip_address_in_router(router, host, controlIp, "eth1", True) self.verify_ip_address_in_router(router, host, sourcenatIp, "eth2", True) self.verify_ip_address_in_router(router, host, ipaddress_3.ipaddress.ipaddress, "eth3", True) self.verify_ip_address_in_router(router, host, ipaddress_4.ipaddress.ipaddress, "eth4", True) self.verify_router_publicnic_state(router, host, "eth2|eth3|eth4") # 14. get a free ip 5 in new ip range 2, assign to network, and create port forwarding rules (ssh) to the vm # verify the available nics in VR should be "eth0,eth1,eth2,eth3,eth4," # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 3, eth4 -> new ip 4/5 ip_address_5 = self.get_free_ipaddress(self.public_ip_range2.vlan.id) ipaddress_5 = PublicIPAddress.create(self.apiclient, zoneid=self.zone.id, networkid=self.network1.id, ipaddress=ip_address_5) nat_rule = NATRule.create(self.apiclient, self.virtual_machine1, self.services["natrule"], ipaddressid=ipaddress_5.ipaddress.id, openfirewall=True) routers = self.get_routers(self.network1.id) for router in routers: host = self.get_router_host(router) self.verify_network_interfaces_in_router( router, host, "eth0,eth1,eth2,eth3,eth4,") guestIp, controlIp, sourcenatIp = self.get_router_ips(router) self.verify_ip_address_in_router(router, host, guestIp, "eth0", True) self.verify_ip_address_in_router(router, host, controlIp, "eth1", True) self.verify_ip_address_in_router(router, host, sourcenatIp, "eth2", True) self.verify_ip_address_in_router(router, host, ipaddress_3.ipaddress.ipaddress, "eth3", True) self.verify_ip_address_in_router(router, host, ipaddress_4.ipaddress.ipaddress, "eth4", True) self.verify_ip_address_in_router(router, host, ipaddress_5.ipaddress.ipaddress, "eth4", True) self.verify_router_publicnic_state(router, host, "eth2|eth3|eth4") # 15. get a free ip 6 in new ip range 2, assign to network, and create port forwarding rules (ssh) to the vm # verify the available nics in VR should be "eth0,eth1,eth2,eth3,eth4," # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 3, eth4 -> new ip 4/5/6 ip_address_6 = self.get_free_ipaddress(self.public_ip_range2.vlan.id) ipaddress_6 = PublicIPAddress.create(self.apiclient, zoneid=self.zone.id, networkid=self.network1.id, ipaddress=ip_address_6) nat_rule = NATRule.create(self.apiclient, self.virtual_machine1, self.services["natrule"], ipaddressid=ipaddress_6.ipaddress.id, openfirewall=True) routers = self.get_routers(self.network1.id) for router in routers: host = self.get_router_host(router) self.verify_network_interfaces_in_router( router, host, "eth0,eth1,eth2,eth3,eth4,") guestIp, controlIp, sourcenatIp = self.get_router_ips(router) self.verify_ip_address_in_router(router, host, guestIp, "eth0", True) self.verify_ip_address_in_router(router, host, controlIp, "eth1", True) self.verify_ip_address_in_router(router, host, sourcenatIp, "eth2", True) self.verify_ip_address_in_router(router, host, ipaddress_3.ipaddress.ipaddress, "eth3", True) self.verify_ip_address_in_router(router, host, ipaddress_4.ipaddress.ipaddress, "eth4", True) self.verify_ip_address_in_router(router, host, ipaddress_5.ipaddress.ipaddress, "eth4", True) self.verify_ip_address_in_router(router, host, ipaddress_6.ipaddress.ipaddress, "eth4", True) self.verify_router_publicnic_state(router, host, "eth2|eth3|eth4") # 16. release new ip 5 # verify the available nics in VR should be "eth0,eth1,eth2,eth3,eth4," # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 3, eth4 -> new ip 4/6 ipaddress_5.delete(self.apiclient) routers = self.get_routers(self.network1.id) for router in routers: host = self.get_router_host(router) self.verify_network_interfaces_in_router( router, host, "eth0,eth1,eth2,eth3,eth4,") guestIp, controlIp, sourcenatIp = self.get_router_ips(router) self.verify_ip_address_in_router(router, host, guestIp, "eth0", True) self.verify_ip_address_in_router(router, host, controlIp, "eth1", True) self.verify_ip_address_in_router(router, host, sourcenatIp, "eth2", True) self.verify_ip_address_in_router(router, host, ipaddress_3.ipaddress.ipaddress, "eth3", True) self.verify_ip_address_in_router(router, host, ipaddress_4.ipaddress.ipaddress, "eth4", True) self.verify_ip_address_in_router(router, host, ipaddress_5.ipaddress.ipaddress, "eth4", False) self.verify_ip_address_in_router(router, host, ipaddress_6.ipaddress.ipaddress, "eth4", True) self.verify_router_publicnic_state(router, host, "eth2|eth3|eth4") # 17. release new ip 4 # verify the available nics in VR should be "eth0,eth1,eth2,eth3,eth4," # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 3, eth4 -> new ip 6 ipaddress_4.delete(self.apiclient) routers = self.get_routers(self.network1.id) for router in routers: host = self.get_router_host(router) self.verify_network_interfaces_in_router( router, host, "eth0,eth1,eth2,eth3,eth4,") guestIp, controlIp, sourcenatIp = self.get_router_ips(router) self.verify_ip_address_in_router(router, host, guestIp, "eth0", True) self.verify_ip_address_in_router(router, host, controlIp, "eth1", True) self.verify_ip_address_in_router(router, host, sourcenatIp, "eth2", True) self.verify_ip_address_in_router(router, host, ipaddress_3.ipaddress.ipaddress, "eth3", True) self.verify_ip_address_in_router(router, host, ipaddress_4.ipaddress.ipaddress, "eth4", False) self.verify_ip_address_in_router(router, host, ipaddress_5.ipaddress.ipaddress, "eth4", False) self.verify_ip_address_in_router(router, host, ipaddress_6.ipaddress.ipaddress, "eth4", True) self.verify_router_publicnic_state(router, host, "eth2|eth3|eth4") # 18. release new ip 3 # verify the available nics in VR should be "eth0,eth1,eth2,eth4," # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth4 -> new ip 6 ipaddress_3.delete(self.apiclient) routers = self.get_routers(self.network1.id) for router in routers: host = self.get_router_host(router) self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth4,") guestIp, controlIp, sourcenatIp = self.get_router_ips(router) self.verify_ip_address_in_router(router, host, guestIp, "eth0", True) self.verify_ip_address_in_router(router, host, controlIp, "eth1", True) self.verify_ip_address_in_router(router, host, sourcenatIp, "eth2", True) self.verify_ip_address_in_router(router, host, ipaddress_4.ipaddress.ipaddress, "eth4", False) self.verify_ip_address_in_router(router, host, ipaddress_5.ipaddress.ipaddress, "eth4", False) self.verify_ip_address_in_router(router, host, ipaddress_6.ipaddress.ipaddress, "eth4", True) self.verify_router_publicnic_state(router, host, "eth2|eth4") # 19. restart network # verify the available nics in VR should be "eth0,eth1,eth2,eth4," # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth4 -> new ip 6 self.network1.restart(self.apiclient) routers = self.get_routers(self.network1.id) for router in routers: host = self.get_router_host(router) self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth4,") guestIp, controlIp, sourcenatIp = self.get_router_ips(router) self.verify_ip_address_in_router(router, host, guestIp, "eth0", True) self.verify_ip_address_in_router(router, host, controlIp, "eth1", True) self.verify_ip_address_in_router(router, host, sourcenatIp, "eth2", True) self.verify_ip_address_in_router(router, host, ipaddress_4.ipaddress.ipaddress, "eth4", False) self.verify_ip_address_in_router(router, host, ipaddress_5.ipaddress.ipaddress, "eth4", False) self.verify_ip_address_in_router(router, host, ipaddress_6.ipaddress.ipaddress, "eth4", True) self.verify_router_publicnic_state(router, host, "eth2|eth4") # 20. reboot router # verify the available nics in VR should be "eth0,eth1,eth2,eth3," # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 6 if len(routers) > 0: router = routers[0] cmd = rebootRouter.rebootRouterCmd() cmd.id = router.id self.apiclient.rebootRouter(cmd) router = self.get_router(router.id) host = self.get_router_host(router) self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth3,") guestIp, controlIp, sourcenatIp = self.get_router_ips(router) self.verify_ip_address_in_router(router, host, guestIp, "eth0", True) self.verify_ip_address_in_router(router, host, controlIp, "eth1", True) self.verify_ip_address_in_router(router, host, sourcenatIp, "eth2", True) self.verify_ip_address_in_router(router, host, ipaddress_4.ipaddress.ipaddress, "eth3", False) self.verify_ip_address_in_router(router, host, ipaddress_5.ipaddress.ipaddress, "eth3", False) self.verify_ip_address_in_router(router, host, ipaddress_6.ipaddress.ipaddress, "eth3", True) self.verify_router_publicnic_state(router, host, "eth2|eth3") # 21. restart network with cleanup # verify the available nics in VR should be "eth0,eth1,eth2,eth3," # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 6 self.network1.restart(self.apiclient, cleanup=True) routers = self.get_routers(self.network1.id) for router in routers: host = self.get_router_host(router) self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth3,") guestIp, controlIp, sourcenatIp = self.get_router_ips(router) self.verify_ip_address_in_router(router, host, guestIp, "eth0", True) self.verify_ip_address_in_router(router, host, controlIp, "eth1", True) self.verify_ip_address_in_router(router, host, sourcenatIp, "eth2", True) self.verify_ip_address_in_router(router, host, ipaddress_4.ipaddress.ipaddress, "eth3", False) self.verify_ip_address_in_router(router, host, ipaddress_5.ipaddress.ipaddress, "eth3", False) self.verify_ip_address_in_router(router, host, ipaddress_6.ipaddress.ipaddress, "eth3", True) # 22. restart network with cleanup, makeredundant=true # verify the available nics in VR should be "eth0,eth1,eth2,eth3," # verify the IPs in VR. eth0 -> guest nic, eth2 -> source nat IP, eth3 -> new ip 6 self.network1.restart(self.apiclient, cleanup=True, makeredundant=True) routers = self.get_routers(self.network1.id) for router in routers: host = self.get_router_host(router) self.verify_network_interfaces_in_router(router, host, "eth0,eth1,eth2,eth3,") guestIp, controlIp, sourcenatIp = self.get_router_ips(router) self.verify_ip_address_in_router(router, host, guestIp, "eth0", True) self.verify_ip_address_in_router(router, host, controlIp, "eth1", True) self.verify_ip_address_in_router(router, host, sourcenatIp, "eth2", True) self.verify_ip_address_in_router(router, host, ipaddress_4.ipaddress.ipaddress, "eth3", False) self.verify_ip_address_in_router(router, host, ipaddress_5.ipaddress.ipaddress, "eth3", False) self.verify_ip_address_in_router(router, host, ipaddress_6.ipaddress.ipaddress, "eth3", True) self.verify_router_publicnic_state(router, host, "eth2|eth3")
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_15_restore_vm_with_template_id(self): """ Test restoring Virtual Machine with template id """ noffering=NetworkOffering.list( self.user_api_client, name="DefaultIsolatedNetworkOfferingWithSourceNatService" ) vm1network=Network.create( self.user_api_client, self.services["network"], accountid=self.account.name, domainid=self.account.domainid, networkofferingid=noffering[0].id, zoneid=self.zone.id ) list_nw_response = Network.list( self.user_api_client, id=vm1network.id ) self.assertEqual( isinstance(list_nw_response, list), True, "Check list response returns a valid networks list" ) restorevm = VirtualMachine.create( self.user_api_client, self.services["small"], networkids=vm1network.id, accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.service_offering.id, mode=self.services['mode'], startvm="true" ) time.sleep(600) list_vm_response = VirtualMachine.list( self.user_api_client, id=restorevm.id ) self.assertEqual( list_vm_response[0].state, "Running", "Check virtual machine is in running state" ) custom_disk_offering=DiskOffering.list( self.user_api_client, name="custom" ) newvolume = Volume.create( self.user_api_client, self.services["volume"], zoneid=self.zone.id, account=self.account.name, domainid=self.domain.id, diskofferingid=custom_disk_offering[0].id, size=1 ) # Attach volume to VM cmd = attachVolume.attachVolumeCmd() cmd.id = newvolume.id cmd.virtualmachineid = restorevm.id cmd.deviceid=1 vol1=self.user_api_client.attachVolume(cmd) cmd = restoreVirtualMachine.restoreVirtualMachineCmd() cmd.virtualmachineid = restorevm.id cmd.templateid = self.xtemplate.id self.user_api_client.restoreVirtualMachine(cmd) time.sleep(600) list_vm_response = VirtualMachine.list( self.user_api_client, id=restorevm.id ) self.assertEqual( isinstance(list_vm_response, list), True, "Check list response returns a valid list" ) self.assertNotEqual( len(list_vm_response), 0, "Check VM available in List Virtual Machines" ) self.assertEqual( list_vm_response[0].state, "Running", "Check virtual machine is in Stopped state" ) restorevm.delete(self.apiclient) vm1network.delete(self.user_api_client) return
def setUpClass(cls): cls.testClient = super(TestVMLifeCycleHostmaintenance, cls).getClsTestClient() cls.api_client = cls.testClient.getApiClient() cls.services = Services().services # Get Zone, Domain and templates cls.domain = get_domain(cls.api_client) cls.zone = get_zone(cls.api_client, cls.testClient.getZoneForTests()) cls.template = get_template(cls.api_client, cls.zone.id, cls.services["ostype"]) cls.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 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 gateway = find_public_gateway(self) ssh_command = "ping -c 3 %s" % gateway check_string = "3 packets received" 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 = self.HTTP_COMMAND % gateway check_string = self.HTTP_CHECK_STRING result = check_router_command(virtual_machine, nat_rule.ipaddress, ssh_command, check_string, self) self.assertEqual( result, expected, self.HTTP_ASSERT_FAILURE_MESSAGE ) EgressFireWallRule.create( self.apiclient, networkid=network.id, protocol=self.services["egress_8080"]["protocol"], startport=self.services["egress_8080"]["startport"], endport=self.services["egress_8080"]["endport"], cidrlist=self.services["egress_8080"]["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 result = check_router_command(virtual_machine, nat_rule.ipaddress, ssh_command, check_string, self) self.assertEqual( result, expected, self.HTTP_ASSERT_SUCCESS_MESSAGE ) return
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 cls.hypervisorNotSupported = False hypervisor = get_hypervisor_type(cls.api_client) if hypervisor.lower() not in ["vmware", "kvm"]: cls.hypervisorNotSupported = True cls._cleanup = [] if not cls.hypervisorNotSupported: # 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 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_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'): 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 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 gateway = find_public_gateway(self) ssh_command = "ping -c 3 %s" % gateway check_string = "3 packets received" 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 = self.HTTP_COMMAND % gateway check_string = self.HTTP_CHECK_STRING result = check_router_command(virtual_machine, nat_rule.ipaddress, ssh_command, check_string, self) self.assertEqual( result, expected, self.HTTP_ASSERT_FAILURE_MESSAGE ) EgressFireWallRule.create( self.apiclient, networkid=network.id, protocol=self.services["egress_8080"]["protocol"], startport=self.services["egress_8080"]["startport"], endport=self.services["egress_8080"]["endport"], cidrlist=self.services["egress_8080"]["cidrlist"] ) expected = 1 result = check_router_command(virtual_machine, nat_rule.ipaddress, ssh_command, check_string, self) self.assertEqual( result, expected, self.HTTP_ASSERT_SUCCESS_MESSAGE ) return
def test_01_create_delete_portforwarding_fornonvpc(self): """ @summary: Test to list, create and delete Port Forwarding for IP Address associated to Non VPC network @Steps: Step1: Creating a Network for the user Step2: Associating an IP Addresses for Network Step3: Launching Virtual Machine in network created in step 2 Step4: Listing Port Forwarding Rules for the IP Address associated in Step2 Step5: Verifying that no Port Forwarding Rules are listed Step6: Creating a Port Forwarding Rule for IP Address associated in Step2 Step7: Listing Port Forwarding Rules for the IP Address associated in Step2 Step8: Verifying 1 Port Forwarding Rule is listed Step9: Deleting the Port Forwarding Rule created in Step6 Step10: Listing Port Forwarding Rules for the IP Address associated in Step2 Step11: Verifying that no Port Forwarding Rules are listed """ # Listing all the Networks's for a user list_networks_before = Network.list( self.userapiclient, listall=self.services["listall"], type="Isolated" ) # Verifying No Networks are listed self.assertIsNone( list_networks_before, "Networks listed for newly created User" ) # Listing Network Offerings network_offerings_list = NetworkOffering.list( self.apiClient, forvpc="false", guestiptype="Isolated", state="Enabled", supportedservices="SourceNat,PortForwarding", zoneid=self.zone.id ) status = validateList(network_offerings_list) self.assertEqual( PASS, status[0], "Isolated Network Offerings with sourceNat,\ PortForwarding enabled are not found" ) # Creating a network network = Network.create( self.userapiclient, self.services["network"], accountid=self.account.name, domainid=self.domain.id, networkofferingid=network_offerings_list[0].id, zoneid=self.zone.id ) self.assertIsNotNone( network, "Network creation failed" ) # Listing all the IP Addresses for a user list_ipaddresses_before = PublicIPAddress.list( self.userapiclient, listall=self.services["listall"] ) # Verifying no IP Addresses are listed self.assertIsNone( list_ipaddresses_before, "IP Addresses listed for newly created User" ) service_offering = ServiceOffering.create( self.apiClient, self.services["service_offerings"]["tiny"], ) self.services["virtual_machine"]["zoneid"] = self.zone.id vm = VirtualMachine.create( self.userapiclient, self.services["virtual_machine"], accountid=self.account.name, domainid=self.account.domainid, networkids=network.id, serviceofferingid=service_offering.id ) VirtualMachine.delete(vm, self.apiClient, expunge=True) # Associating an IP Addresses to Network created associated_ipaddress = PublicIPAddress.create( self.userapiclient, services=self.services["network"], networkid=network.id ) self.assertIsNotNone( associated_ipaddress, "Failed to Associate IP Address" ) # Listing all the IP Addresses for a user list_ipaddresses_after = PublicIPAddress.list( self.userapiclient, listall=self.services["listall"] ) status = validateList(list_ipaddresses_after) self.assertEqual( PASS, status[0], "IP Addresses Association Failed" ) # Verifying the length of the list is 2 self.assertEqual( 2, len(list_ipaddresses_after), "Number of IP Addresses associated are not matching expected" ) # Launching a Virtual Machine with above created Network vm_created = VirtualMachine.create( self.userapiclient, self.services["virtual_machine"], accountid=self.account.name, domainid=self.account.domainid, networkids=network.id, serviceofferingid=self.service_offering.id, ) self.assertIsNotNone( vm_created, "Failed to launch a VM under network created" ) self.cleanup.append(network) # Listing Virtual Machines in running state in above created network list_vms_running = VirtualMachine.list( self.userapiclient, listall=self.services["listall"], state="Running", networkid=network.id ) status = validateList(list_vms_running) self.assertEqual( PASS, status[0], "VM Created is not in Running state" ) # Verifying the length of the list is 2 self.assertEqual( 2, len(list_ipaddresses_after), "VM Created is not in Running state" ) self.assertEqual( vm_created.id, list_vms_running[0].id, "VM Created is not in Running state" ) # Listing Virtual Machines in stopped state in above created network list_vms_stopped = VirtualMachine.list( self.userapiclient, listall=self.services["listall"], state="Stopped", networkid=network.id ) # Verifying no VMs are in stopped state self.assertIsNone( list_vms_stopped, "VM Created is in stopped state" ) # Listing Port Forwarding Rules for the IP Address associated list_prtfwdrule_before = NATRule.list( self.userapiclient, listall=self.services["listall"], ipaddressid=associated_ipaddress.ipaddress.id ) # Verifying no port forwarding rules are listed self.assertIsNone( list_prtfwdrule_before, "Port Forwarding Rules listed for newly associated IP Address" ) # Creating a Port Forwarding rule portfwd_rule = NATRule.create( self.userapiclient, virtual_machine=vm_created, services=self.services["natrule"], ipaddressid=associated_ipaddress.ipaddress.id, ) self.assertIsNotNone( portfwd_rule, "Failed to create Port Forwarding Rule" ) # Verifying details of Sticky Policy created # Creating expected and actual values dictionaries expected_dict = { "ipaddressid": associated_ipaddress.ipaddress.id, "privateport": str(self.services["natrule"]["privateport"]), "publicport": str(self.services["natrule"]["publicport"]), "protocol": str(self.services["natrule"]["protocol"]).lower(), } actual_dict = { "ipaddressid": portfwd_rule.ipaddressid, "privateport": str(portfwd_rule.privateport), "publicport": str(portfwd_rule.publicport), "protocol": portfwd_rule.protocol, } portfwd_status = self.__verify_values( expected_dict, actual_dict ) self.assertEqual( True, portfwd_status, "Created Port Forward Rule details are not as expected" ) # Listing Port Forwarding Rules for the IP Address associated list_prtfwdrule_after = NATRule.list( self.userapiclient, listall=self.services["listall"], ipaddressid=associated_ipaddress.ipaddress.id ) status = validateList(list_prtfwdrule_after) self.assertEqual( PASS, status[0], "Failed to create Port Forwarding Rule" ) # Verifying the length of the list is 1 self.assertEqual( 1, len(list_prtfwdrule_after), "Failed to create Port Forwarding Rule" ) # Deleting Port Forwarding Rule portfwd_rule.delete(self.userapiclient) # Creating a Port Forwarding rule with port range portfwd_rule = NATRule.create( self.userapiclient, virtual_machine=vm_created, services=self.services["natrulerange"], ipaddressid=associated_ipaddress.ipaddress.id, ) self.assertIsNotNone( portfwd_rule, "Failed to create Port Forwarding Rule" ) # update the private port for port forwarding rule updatefwd_rule = portfwd_rule.update(self.userapiclient, portfwd_rule.id, virtual_machine=vm_created, services=self.services["updatenatrulerange"], ) # Verifying details of Sticky Policy created # Creating expected and actual values dictionaries expected_dict = { "privateport": str(self.services["updatenatrulerange"]["privateport"]), "privateendport": str(self.services["updatenatrulerange"]["privateendport"]), } actual_dict = { "privateport": str(updatefwd_rule.privateport), "privateendport": str(updatefwd_rule.privateendport), } portfwd_status = self.__verify_values( expected_dict, actual_dict ) self.assertEqual( True, portfwd_status, "Updated Port Forward Rule details are not as expected" ) # Deleting Port Forwarding Rule portfwd_rule.delete(self.userapiclient) # Listing Port Forwarding Rules for the IP Address associated list_prtfwdrule_after = NATRule.list( self.userapiclient, listall=self.services["listall"], ipaddressid=associated_ipaddress.ipaddress.id ) # Verifying no port forwarding rules are listed self.assertIsNone( list_prtfwdrule_after, "Port Forwarding Rules listed after deletion" ) # Destroying the VM Launched vm_created.delete(self.apiClient) self.cleanup.append(self.account) return
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")