def test_02_create_vpc_wait_gc(self): """ Test VPC when host is in maintenance mode and wait till nw gc """ # Validate the following # 1. Put the host in maintenance mode. # 2. Attempt to Create a VPC with cidr - 10.1.1.1/16 # 3. Wait for the VPC GC thread to run. # 3. VPC will be created but will be in "Disabled" state and should # get deleted self.debug("creating a VPC network in the account: %s" % self.account.name) self.services["vpc"]["cidr"] = '10.1.1.1/16' vpc = VPC.create(self.apiclient, self.services["vpc"], vpcofferingid=self.vpc_off.id, zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, start=False) self.validate_vpc_network(vpc, state='inactive') interval = list_configurations(self.apiclient, name='network.gc.interval') wait = list_configurations(self.apiclient, name='network.gc.wait') self.debug("Sleep till network gc thread runs..") # Sleep to ensure that all resources are deleted time.sleep(int(interval[0].value) + int(wait[0].value)) vpcs = VPC.list(self.apiclient, id=vpc.id, listall=True) self.assertEqual( vpcs, None, "List VPC should not return anything after network gc") return
def test_07_snapshot_to_template_bypass_secondary(self): ''' Create template from snapshot bypassing secondary storage ''' ##cls.virtual_machine volume = list_volumes(self.apiclient, virtualmachineid=self.virtual_machine.id) snapshot = Snapshot.create(self.apiclient, volume_id=volume[0].id) backup_config = list_configurations(self.apiclient, name="sp.bypass.secondary.storage") if (backup_config[0].value == "false"): backup_config = Configurations.update( self.apiclient, name="sp.bypass.secondary.storage", value="true") self.assertIsNotNone(snapshot, "Could not create snapshot") self.assertIsInstance(snapshot, Snapshot, "Snapshot is not an instance of Snapshot") template = self.create_template_from_snapshot(self.apiclient, self.services, snapshotid=snapshot.id) virtual_machine = VirtualMachine.create( self.apiclient, {"name": "StorPool-%d" % random.randint(0, 100)}, zoneid=self.zone.id, templateid=template.id, serviceofferingid=self.service_offering.id, hypervisor=self.hypervisor, rootdisksize=10) ssh_client = virtual_machine.get_ssh_client() self.assertIsNotNone(template, "Template is None") self.assertIsInstance(template, Template, "Template is instance of template") self._cleanup.append(snapshot) self._cleanup.append(template)
def test_02_create_vpc_wait_gc(self): """ Test VPC when host is in maintenance mode and wait till nw gc """ # Validate the following # 1. Put the host in maintenance mode. # 2. Attempt to Create a VPC with cidr - 10.1.1.1/16 # 3. Wait for the VPC GC thread to run. # 3. VPC will be created but will be in "Disabled" state and should # get deleted self.debug("creating a VPC network in the account: %s" % self.account.name) self.services["vpc"]["cidr"] = '10.1.1.1/16' vpc = VPC.create( self.apiclient, self.services["vpc"], vpcofferingid=self.vpc_off.id, zoneid=self.zone.id, account=self.account.name, domainid=self.account.domainid, start=False ) self.validate_vpc_network(vpc, state='inactive') interval = list_configurations( self.apiclient, name='network.gc.interval' ) wait = list_configurations( self.apiclient, name='network.gc.wait' ) self.debug("Sleep till network gc thread runs..") # Sleep to ensure that all resources are deleted time.sleep(int(interval[0].value) + int(wait[0].value)) vpcs = VPC.list( self.apiclient, id=vpc.id, listall=True ) self.assertEqual( vpcs, None, "List VPC should not return anything after network gc" ) return
def tearDown(self): try: # Clean up, terminate the created network offerings cleanup_resources(self.apiclient, self.cleanup) self.account.delete(self.apiclient) interval = list_configurations(self.apiclient, name="account.cleanup.interval") # Sleep to ensure that all resources are deleted time.sleep(int(interval[0].value) * 2) except Exception as e: raise Exception("Warning: Exception during cleanup : %s" % e) return
def get_remote_cluster(cls, apiclient, zoneid): storpool_clusterid = subprocess.check_output( ['storpool_confshow', 'CLUSTER_ID']) clusterid = storpool_clusterid.split("=") logging.debug(storpool_clusterid) clusters = list_clusters(apiclient, zoneid=zoneid) for c in clusters: configuration = list_configurations(apiclient, clusterid=c.id) for conf in configuration: if conf.name == 'sp.cluster.id' and (conf.value not in clusterid[1]): return c
def bypass_secondary(cls, bypassed): if bypassed: backup_config = Configurations.update(cls.testClass.apiclient, name = "sp.bypass.secondary.storage", value = "true") else: backup_config = Configurations.update(cls.testClass.apiclient, name = "sp.bypass.secondary.storage", value = "false") cfg.logger.info(list_configurations( cls.testClass.apiclient, name = "sp.bypass.secondary.storage"))
def get_local_cluster(self): storpool_clusterid = subprocess.check_output(['storpool_confshow', 'CLUSTER_ID']) clusterid = storpool_clusterid.split("=") clusters = list_clusters(self.testClass.apiclient) for c in clusters: configuration = list_configurations( self.testClass.apiclient, clusterid = c.id ) for conf in configuration: if conf.name == 'sp.cluster.id' and (conf.value in clusterid[1]): return c
def tearDown(self): try: # Clean up, terminate the created network offerings cleanup_resources(self.apiclient, self.cleanup) self.account.delete(self.apiclient) interval = list_configurations(self.apiclient, name='account.cleanup.interval') # Sleep to ensure that all resources are deleted time.sleep(int(interval[0].value) * 2) except Exception as e: raise Exception("Warning: Exception during cleanup : %s" % e) return
def test_delete_account(self): """Test for delete account""" # Validate the Following # 1. after account.cleanup.interval (global setting) # time all the PF/LB rules should be deleted # 2. verify that list(LoadBalancer/PortForwarding)Rules # API does not return any rules for the account # 3. The domR should have been expunged for this account self.account.delete(self.apiclient) interval = list_configurations(self.apiclient, name='account.cleanup.interval') self.assertEqual(isinstance(interval, list), True, "Check if account.cleanup.interval config present") # Sleep to ensure that all resources are deleted time.sleep(int(interval[0].value)) # ListLoadBalancerRules should not list # associated rules with deleted account # Unable to find account testuser1 in domain 1 : Exception try: list_lb_rules(self.apiclient, account=self.account.name, domainid=self.account.domainid) except CloudstackAPIException: self.debug("Port Forwarding Rule is deleted") # ListPortForwardingRules should not # list associated rules with deleted account try: list_nat_rules(self.apiclient, account=self.account.name, domainid=self.account.domainid) except CloudstackAPIException: self.debug("NATRule is deleted") # Retrieve router for the user account try: routers = list_routers(self.apiclient, account=self.account.name, domainid=self.account.domainid) self.assertEqual(routers, None, "Check routers are properly deleted.") except CloudstackAPIException: self.debug("Router is deleted") except Exception as e: raise Exception( "Encountered %s raised while fetching routers for account: %s" % (e, self.account.name)) return
def test_06_snapshot_to_template_secondary_storage(self): ''' Create template from snapshot ''' volume = Volume.list(self.apiclient, virtualmachineid=self.virtual_machine.id, type="ROOT", listall=True) volume = volume[0] backup_config = list_configurations(self.apiclient, name="sp.bypass.secondary.storage") if (backup_config[0].value == "true"): backup_config = Configurations.update( self.apiclient, name="sp.bypass.secondary.storage", value="false") snapshot = Snapshot.create(self.apiclient, volume_id=volume.id, account=self.account.name, domainid=self.account.domainid) self.assertIsNotNone(snapshot, "Could not create snapshot") self.assertIsInstance(snapshot, Snapshot, "Snapshot is not an instance of Snapshot") template = self.helper.create_template_from_snapshot( self.apiclient, self.services, snapshotid=snapshot.id) virtual_machine = VirtualMachine.create( self.apiclient, {"name": "StorPool-%s" % uuid.uuid4()}, zoneid=self.zone.id, templateid=template.id, accountid=self.account.name, domainid=self.account.domainid, serviceofferingid=self.service_offering.id, hypervisor=self.hypervisor, rootdisksize=10) self.assertIsNotNone(template, "Template is None") self.assertIsInstance(template, Template, "Template is instance of template") ssh_client = virtual_machine.get_ssh_client(reconnect=True) self._cleanup.append(template)
def test_02_NetworkGarbageCollection(self): """Test network garbage collection """ # Validate the following # 1. wait for router to start and guest network to be created # a.listRouters account=user, domainid=1 (router state=Running) # b.listNetworks account=user domainid=1 (network state=Implemented) # c.listVirtualMachines account=user domainid=1 (VM states=Running) # 4. stopVirtualMachines (stop all VMs in this account) # 5. wait for VMs to stop-listVirtualMachines account=user, domainid=1 # (Both VM states = Stopped) # 6. wait for network.gc.interval*2 seconds (600s) # 7. listRouters account=user, domainid=1 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 associated with account should be in running state timeout = 180 router = routers[0] self.debug("Router ID: %s & Router state: %s" % (router.id, router.state)) self.debug("Wait for %s secs max for router to reach Running state" % timeout) while timeout: time.sleep(60) routers = list_routers(self.apiclient, account=self.account.name, domainid=self.account.domainid, id=router.id) router = routers[0] if router.state == 'Running': break timeout = timeout - 60 if timeout == 0: self.assertEqual(router.state, 'Running', "Router not in Running state") # Network state associated with account should be 'Implemented' networks = list_networks(self.apiclient, account=self.account.name, domainid=self.account.domainid, type='Isolated') self.assertEqual(isinstance(networks, list), True, "Check for list networks response return valid data") self.assertNotEqual(len(networks), 0, "Check list networks response") # Check if network in 'Implemented' state for network in networks: self.debug("Network ID: %s & Network state: %s" % (network.id, network.state)) self.assertIn(network.state, ['Implemented', 'Allocated'], "Check list network response for network state") # VM state associated with account should be 'Running' virtual_machines = list_virtual_machines( self.apiclient, account=self.account.name, domainid=self.account.domainid, ) self.assertEqual( isinstance(virtual_machines, list), True, "Check for list virtual machines response return valid data") self.assertNotEqual(len(virtual_machines), 0, "Check list virtual machines response") for virtual_machine in virtual_machines: self.debug("VM ID: %s & VM state: %s" % (virtual_machine.id, virtual_machine.state)) self.assertEqual(virtual_machine.state, 'Running', "Check list VM response for Running state") # Stop virtual machine cmd = stopVirtualMachine.stopVirtualMachineCmd() cmd.id = virtual_machine.id self.apiclient.stopVirtualMachine(cmd) gcinterval = list_configurations(self.apiclient, name='network.gc.interval') self.assertEqual( isinstance(gcinterval, list), True, "Check for list intervals response return valid data") self.debug("network.gc.interval: %s" % gcinterval[0].value) gcwait = list_configurations(self.apiclient, name='network.gc.wait') self.assertEqual( isinstance(gcwait, list), True, "Check for list intervals response return valid data") self.debug("network.gc.wait: %s" % gcwait[0].value) total_wait = int(gcinterval[0].value) + int(gcwait[0].value) # Router is stopped after (network.gc.interval *2) time. Wait for # (network.gc.interval+network.gc.wait) * 2 for moving # router to 'Stopped' time.sleep(total_wait * 2) 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") for router in routers: self.debug("Router ID: %s & Router state: %s" % (router.id, router.state)) self.assertEqual(router.state, 'Stopped', "Check list router response for router state") # Cleanup Vm_2 - Not required for further tests self.cleanup.append(self.vm_2) return
def test_delete_account(self): """Test for delete account""" # Validate the Following # 1. after account.cleanup.interval (global setting) # time all the PF/LB rules should be deleted # 2. verify that list(LoadBalancer/PortForwarding)Rules # API does not return any rules for the account # 3. The domR should have been expunged for this account self.account.delete(self.apiclient) interval = list_configurations( self.apiclient, name='account.cleanup.interval' ) self.assertEqual( isinstance(interval, list), True, "Check if account.cleanup.interval config present" ) # Sleep to ensure that all resources are deleted time.sleep(int(interval[0].value)) # ListLoadBalancerRules should not list # associated rules with deleted account # Unable to find account testuser1 in domain 1 : Exception try: list_lb_rules( self.apiclient, account=self.account.name, domainid=self.account.domainid ) except CloudstackAPIException: self.debug("Port Forwarding Rule is deleted") # ListPortForwardingRules should not # list associated rules with deleted account try: list_nat_rules( self.apiclient, account=self.account.name, domainid=self.account.domainid ) except CloudstackAPIException: self.debug("NATRule is deleted") # Retrieve router for the user account try: routers = list_routers( self.apiclient, account=self.account.name, domainid=self.account.domainid ) self.assertEqual( routers, None, "Check routers are properly deleted." ) except CloudstackAPIException: self.debug("Router is deleted") except Exception as e: raise Exception( "Encountered %s raised while fetching routers for account: %s" % (e, self.account.name)) return
def setUpClass(cls): cls.testClient = super(TestResizeVolume, cls).getClsTestClient() cls.api_client = cls.testClient.getApiClient() cls.hypervisor = (cls.testClient.getHypervisorInfo()).lower() cls.storageID = None # Fill services from the external config file 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._cleanup = [] cls.unsupportedStorageType = False cls.unsupportedHypervisorType = False cls.updateclone = False if cls.hypervisor not in ['xenserver',"kvm","vmware"]: cls.unsupportedHypervisorType=True return cls.template = get_template( cls.api_client, cls.zone.id ) cls.services["virtual_machine"]["zoneid"] = cls.zone.id cls.services["virtual_machine"]["template"] = cls.template.id cls.services["volume"]["zoneid"] = cls.zone.id try: cls.parent_domain = Domain.create(cls.api_client, services=cls.services[ "domain"], parentdomainid=cls.domain.id) cls.parentd_admin = Account.create(cls.api_client, cls.services["account"], admin=True, domainid=cls.parent_domain.id) cls._cleanup.append(cls.parentd_admin) cls._cleanup.append(cls.parent_domain) list_pool_resp = list_storage_pools(cls.api_client, account=cls.parentd_admin.name,domainid=cls.parent_domain.id) res = validateList(list_pool_resp) if res[2]== INVALID_INPUT: raise Exception("Failed to list storage pool-no storagepools found ") #Identify the storage pool type and set vmware fullclone to true if storage is VMFS if cls.hypervisor == 'vmware': for strpool in list_pool_resp: if strpool.type.lower() == "vmfs" or strpool.type.lower()== "networkfilesystem": list_config_storage_response = list_configurations( cls.api_client , name= "vmware.create.full.clone",storageid=strpool.id) res = validateList(list_config_storage_response) if res[2]== INVALID_INPUT: raise Exception("Failed to list configurations ") if list_config_storage_response[0].value == "false": Configurations.update(cls.api_client, "vmware.create.full.clone", value="true",storageid=strpool.id) cls.updateclone = True StoragePool.update(cls.api_client,id=strpool.id,tags="scsi") cls.storageID = strpool.id cls.unsupportedStorageType = False break else: cls.unsupportedStorageType = True # Creating service offering with normal config cls.service_offering = ServiceOffering.create( cls.api_client, cls.services["service_offering"]) cls.services_offering_vmware=ServiceOffering.create( cls.api_client,cls.services["service_offering"],tags="scsi") cls._cleanup.extend([cls.service_offering,cls.services_offering_vmware]) except Exception as e: cls.tearDownClass() return
def setUpClass(cls): cls.cloudstacktestclient = super(TestDeployVmRootSize, cls).getClsTestClient() cls.api_client = cls.cloudstacktestclient.getApiClient() cls.hypervisor = cls.cloudstacktestclient.getHypervisorInfo().lower() cls.mgtSvrDetails = cls.config.__dict__["mgtSvr"][0].__dict__ # Get Zone, Domain and Default Built-in template cls.domain = get_domain(cls.api_client) cls.zone = get_zone(cls.api_client, cls.cloudstacktestclient.getZoneForTests()) cls.services = cls.testClient.getParsedTestDataConfig() cls.services["mode"] = cls.zone.networktype cls._cleanup = [] cls.updateclone = False cls.restartreq = False cls.defaultdiskcontroller = "ide" cls.template = get_template(cls.api_client, cls.zone.id) if cls.template == FAILED: assert False, "get_template() failed to return template " #create a user account cls.account = Account.create(cls.api_client, cls.services["account"], domainid=cls.domain.id, admin=True) cls._cleanup.append(cls.account) list_pool_resp = list_storage_pools(cls.api_client, account=cls.account.name, domainid=cls.domain.id) #Identify the storage pool type and set vmware fullclone to # true if storage is VMFS if cls.hypervisor == 'vmware': # please make sure url of templateregister dictionary in # test_data.config pointing to .ova file list_config_storage_response = list_configurations( cls.api_client, name="vmware.root.disk.controller") cls.defaultdiskcontroller = list_config_storage_response[0].value if list_config_storage_response[0].value == "ide" or \ list_config_storage_response[0].value == \ "osdefault": Configurations.update(cls.api_client, "vmware.root.disk.controller", value="scsi") cls.updateclone = True cls.restartreq = True list_config_fullclone_global_response = list_configurations( cls.api_client, name="vmware.create.full.clone") if list_config_fullclone_global_response[0].value == "false": Configurations.update(cls.api_client, "vmware.create.full.clone", value="true") cls.updateclone = True cls.restartreq = True for strpool in list_pool_resp: if strpool.type.lower() == "vmfs" or strpool.type.lower( ) == "networkfilesystem": list_config_storage_response = list_configurations( cls.api_client, name="vmware.create.full.clone", storageid=strpool.id) res = validateList(list_config_storage_response) if res[2] == INVALID_INPUT: raise Exception("Failed to list configurations ") if list_config_storage_response[0].value == "false": Configurations.update(cls.api_client, "vmware.create.full.clone", value="true", storageid=strpool.id) cls.updateclone = True StoragePool.update(cls.api_client, id=strpool.id, tags="scsi") cls.storageID = strpool.id break if cls.restartreq: cls.restartServer() #Giving 30 seconds to management to warm-up, #Experienced failures when trying to deploy a VM exactly when management came up time.sleep(30) #create a service offering cls.service_offering = ServiceOffering.create( cls.api_client, cls.services["service_offering"]) #build cleanup list cls.services_offering_vmware = ServiceOffering.create( cls.api_client, cls.services["service_offering"], tags="scsi") cls._cleanup.extend( [cls.service_offering, cls.services_offering_vmware])
def setUpClass(cls): cls.cloudstacktestclient = super(TestDeployVmRootSize, cls).getClsTestClient() cls.api_client = cls.cloudstacktestclient.getApiClient() cls.hypervisor = cls.cloudstacktestclient.getHypervisorInfo().lower() cls.mgtSvrDetails = cls.config.__dict__["mgtSvr"][0].__dict__ # Get Zone, Domain and Default Built-in template cls.domain = get_domain(cls.api_client) cls.zone = get_zone(cls.api_client, cls.cloudstacktestclient.getZoneForTests()) cls.services = cls.testClient.getParsedTestDataConfig() cls.services["mode"] = cls.zone.networktype cls._cleanup = [] cls.updateclone = False cls.restartreq = False cls.defaultdiskcontroller = "ide" cls.template = get_template(cls.api_client, cls.zone.id) if cls.template == FAILED: assert False, "get_template() failed to return template " #create a user account cls.account = Account.create( cls.api_client, cls.services["account"], domainid=cls.domain.id,admin=True ) cls._cleanup.append(cls.account) list_pool_resp = list_storage_pools(cls.api_client, account=cls.account.name, domainid=cls.domain.id) #Identify the storage pool type and set vmware fullclone to # true if storage is VMFS if cls.hypervisor == 'vmware': # please make sure url of templateregister dictionary in # test_data.config pointing to .ova file list_config_storage_response = list_configurations( cls.api_client , name= "vmware.root.disk.controller") cls.defaultdiskcontroller = list_config_storage_response[0].value if list_config_storage_response[0].value == "ide" or \ list_config_storage_response[0].value == \ "osdefault": Configurations.update(cls.api_client, "vmware.root.disk.controller", value="scsi") cls.updateclone = True cls.restartreq = True list_config_fullclone_global_response = list_configurations( cls.api_client , name= "vmware.create.full.clone") if list_config_fullclone_global_response[0].value=="false": Configurations.update(cls.api_client, "vmware.create.full.clone", value="true") cls.updateclone = True cls.restartreq = True cls.tempobj = Template.register(cls.api_client, cls.services["templateregister"], hypervisor=cls.hypervisor, zoneid=cls.zone.id, account=cls.account.name, domainid=cls.domain.id ) cls.tempobj.download(cls.api_client) for strpool in list_pool_resp: if strpool.type.lower() == "vmfs" or strpool.type.lower()== "networkfilesystem": list_config_storage_response = list_configurations( cls.api_client , name= "vmware.create.full.clone",storageid=strpool.id) res = validateList(list_config_storage_response) if res[2]== INVALID_INPUT: raise Exception("Failed to list configurations ") if list_config_storage_response[0].value == "false": Configurations.update(cls.api_client, "vmware.create.full.clone", value="true", storageid=strpool.id) cls.updateclone = True StoragePool.update(cls.api_client,id=strpool.id, tags="scsi") cls.storageID = strpool.id break if cls.restartreq: cls.restartServer() #create a service offering cls.service_offering = ServiceOffering.create( cls.api_client, cls.services["service_offering"] ) #build cleanup list cls.services_offering_vmware=ServiceOffering.create( cls.api_client,cls.services["service_offering"],tags="scsi") cls._cleanup.extend([cls.service_offering,cls.services_offering_vmware])
def test_02_NetworkGarbageCollection(self): """Test network garbage collection """ # Validate the following # 1. wait for router to start and guest network to be created # a.listRouters account=user, domainid=1 (router state=Running) # b.listNetworks account=user domainid=1 (network state=Implemented) # c.listVirtualMachines account=user domainid=1 (VM states=Running) # 4. stopVirtualMachines (stop all VMs in this account) # 5. wait for VMs to stop-listVirtualMachines account=user, domainid=1 # (Both VM states = Stopped) # 6. wait for network.gc.interval*2 seconds (600s) # 7. listRouters account=user, domainid=1 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 associated with account should be in running state timeout = 180 router = routers[0] self.debug("Router ID: %s & Router state: %s" % ( router.id, router.state )) self.debug( "Wait for %s secs max for router to reach Running state" % timeout) while timeout: time.sleep(60) routers = list_routers( self.apiclient, account=self.account.name, domainid=self.account.domainid, id=router.id) router = routers[0] if router.state == 'Running': break timeout = timeout - 60 if timeout == 0: self.assertEqual( router.state, 'Running', "Router not in Running state") # Network state associated with account should be 'Implemented' networks = list_networks( self.apiclient, account=self.account.name, domainid=self.account.domainid, type='Isolated' ) self.assertEqual( isinstance(networks, list), True, "Check for list networks response return valid data" ) self.assertNotEqual( len(networks), 0, "Check list networks response" ) # Check if network in 'Implemented' state for network in networks: self.debug("Network ID: %s & Network state: %s" % ( network.id, network.state )) self.assertIn( network.state, ['Implemented', 'Allocated'], "Check list network response for network state" ) # VM state associated with account should be 'Running' virtual_machines = list_virtual_machines( self.apiclient, account=self.account.name, domainid=self.account.domainid, ) self.assertEqual( isinstance(virtual_machines, list), True, "Check for list virtual machines response return valid data" ) self.assertNotEqual( len(virtual_machines), 0, "Check list virtual machines response" ) for virtual_machine in virtual_machines: self.debug("VM ID: %s & VM state: %s" % ( virtual_machine.id, virtual_machine.state )) self.assertEqual( virtual_machine.state, 'Running', "Check list VM response for Running state" ) # Stop virtual machine cmd = stopVirtualMachine.stopVirtualMachineCmd() cmd.id = virtual_machine.id self.apiclient.stopVirtualMachine(cmd) gcinterval = list_configurations( self.apiclient, name='network.gc.interval' ) self.assertEqual( isinstance(gcinterval, list), True, "Check for list intervals response return valid data" ) self.debug("network.gc.interval: %s" % gcinterval[0].value) gcwait = list_configurations( self.apiclient, name='network.gc.wait' ) self.assertEqual( isinstance(gcwait, list), True, "Check for list intervals response return valid data" ) self.debug("network.gc.wait: %s" % gcwait[0].value) total_wait = int(gcinterval[0].value) + int(gcwait[0].value) # Router is stopped after (network.gc.interval *2) time. Wait for # (network.gc.interval+network.gc.wait) * 2 for moving # router to 'Stopped' time.sleep(total_wait * 2) 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" ) for router in routers: self.debug("Router ID: %s & Router state: %s" % ( router.id, router.state )) self.assertEqual( router.state, 'Stopped', "Check list router response for router state" ) # Cleanup Vm_2 - Not required for further tests self.cleanup.append(self.vm_2) return
def setUpClass(cls): cls.testClient = super(TestResizeVolume, cls).getClsTestClient() cls.api_client = cls.testClient.getApiClient() cls.hypervisor = (cls.testClient.getHypervisorInfo()).lower() cls.storageID = None # Fill services from the external config file 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._cleanup = [] cls.unsupportedStorageType = False cls.unsupportedHypervisorType = False cls.updateclone = False if cls.hypervisor not in ['xenserver', "kvm", "vmware"]: cls.unsupportedHypervisorType = True return cls.template = get_template(cls.api_client, cls.zone.id) cls.services["virtual_machine"]["zoneid"] = cls.zone.id cls.services["virtual_machine"]["template"] = cls.template.id cls.services["volume"]["zoneid"] = cls.zone.id try: cls.parent_domain = Domain.create(cls.api_client, services=cls.services["domain"], parentdomainid=cls.domain.id) cls.parentd_admin = Account.create(cls.api_client, cls.services["account"], admin=True, domainid=cls.parent_domain.id) cls._cleanup.append(cls.parentd_admin) cls._cleanup.append(cls.parent_domain) list_pool_resp = list_storage_pools(cls.api_client, account=cls.parentd_admin.name, domainid=cls.parent_domain.id) res = validateList(list_pool_resp) if res[2] == INVALID_INPUT: raise Exception( "Failed to list storage pool-no storagepools found ") #Identify the storage pool type and set vmware fullclone to true if storage is VMFS if cls.hypervisor == 'vmware': for strpool in list_pool_resp: if strpool.type.lower() == "vmfs" or strpool.type.lower( ) == "networkfilesystem": list_config_storage_response = list_configurations( cls.api_client, name="vmware.create.full.clone", storageid=strpool.id) res = validateList(list_config_storage_response) if res[2] == INVALID_INPUT: raise Exception("Failed to list configurations ") if list_config_storage_response[0].value == "false": Configurations.update(cls.api_client, "vmware.create.full.clone", value="true", storageid=strpool.id) cls.updateclone = True StoragePool.update(cls.api_client, id=strpool.id, tags="scsi") cls.storageID = strpool.id cls.unsupportedStorageType = False break else: cls.unsupportedStorageType = True # Creating service offering with normal config cls.service_offering = ServiceOffering.create( cls.api_client, cls.services["service_offering"]) cls.services_offering_vmware = ServiceOffering.create( cls.api_client, cls.services["service_offering"], tags="scsi") cls._cleanup.extend( [cls.service_offering, cls.services_offering_vmware]) except Exception as e: cls.tearDownClass() return
def test_04_try_delete_primary_with_template(self): virtual_machine = VirtualMachine.create( self.apiclient, {"name": "StorPool-%s" % uuid.uuid4()}, zoneid=self.zone.id, templateid=self.template.id, serviceofferingid=self.serviceOfferings.id, hypervisor=self.hypervisor, rootdisksize=10) volume = list_volumes(self.apiclient, virtualmachineid=virtual_machine.id, type="ROOT", listall=True) volume = volume[0] name = volume.path.split("/")[3] try: spvolume = self.spapi.volumeList(volumeName="~" + name) if spvolume[0].templateName != self.template_name: raise Exception( "Storpool volume's template %s is not with the same template %s" % (spvolume[0].templateName, self.template_name)) except spapi.ApiError as err: raise Exception(err) backup_config = list_configurations(self.apiclient, name="sp.bypass.secondary.storage") if (backup_config[0].value == "false"): backup_config = Configurations.update( self.apiclient, name="sp.bypass.secondary.storage", value="true") snapshot = Snapshot.create( self.apiclient, volume_id=volume.id, ) self.debug("###################### %s" % snapshot) id = self.helper.get_snapshot_template_id(self.apiclient, snapshot, self.storage_pool_id) if id is None: raise Exception("There isn't primary storgae id") virtual_machine.delete(self.apiclient, expunge=True) pool = list_storage_pools(self.apiclient, id=id) services = { "displaytext": "Template-1", "name": "Template-1-name", "ostypeid": self.template.ostypeid, "ispublic": "true" } template = Template.create_from_snapshot(self.apiclient, snapshot=snapshot, services=services) Snapshot.delete(snapshot, self.apiclient) try: StoragePool.delete(self.sp_primary_storage, self.apiclient) except Exception as err: StoragePool.cancelMaintenance(self.apiclient, id=self.sp_primary_storage.id) self.debug("Storge pool could not be delete due to %s" % err) Template.delete(template, self.apiclient)