| # Licensed to the Apache Software Foundation (ASF) under one | |
| # or more contributor license agreements. See the NOTICE file | |
| # distributed with this work for additional information | |
| # regarding copyright ownership. The ASF licenses this file | |
| # to you under the Apache License, Version 2.0 (the | |
| # "License"); you may not use this file except in compliance | |
| # with the License. You may obtain a copy of the License at | |
| # | |
| # http://www.apache.org/licenses/LICENSE-2.0 | |
| # | |
| # Unless required by applicable law or agreed to in writing, | |
| # software distributed under the License is distributed on an | |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| # KIND, either express or implied. See the License for the | |
| # specific language governing permissions and limitations | |
| # under the License. | |
| """ tests for Volume improvement (Destroy/Recover) in cloudstack 4.14.0.0 | |
| """ | |
| # Import Local Modules | |
| from nose.plugins.attrib import attr | |
| from marvin.cloudstackTestCase import cloudstackTestCase | |
| from marvin.cloudstackAPI import (deleteVolume, extractVolume, recoverVolume) | |
| from marvin.lib.utils import (validateList, | |
| cleanup_resources) | |
| from marvin.lib.base import (Resources, | |
| Volume, | |
| Account, | |
| Domain, | |
| Network, | |
| NetworkOffering, | |
| VirtualMachine, | |
| ServiceOffering, | |
| DiskOffering, | |
| Zone) | |
| from marvin.lib.common import (get_domain, | |
| get_zone, | |
| get_template, | |
| matchResourceCount, | |
| isAccountResourceCountEqualToExpectedCount) | |
| from marvin.codes import (PASS, FAILED, RESOURCE_PRIMARY_STORAGE, RESOURCE_VOLUME) | |
| import logging | |
| import random | |
| import time | |
| class TestVolumeDestroyRecover(cloudstackTestCase): | |
| @classmethod | |
| def setUpClass(cls): | |
| cls.testClient = super( | |
| TestVolumeDestroyRecover, | |
| cls).getClsTestClient() | |
| cls.apiclient = cls.testClient.getApiClient() | |
| cls.services = cls.testClient.getParsedTestDataConfig() | |
| zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests()) | |
| cls.zone = Zone(zone.__dict__) | |
| cls._cleanup = [] | |
| cls.logger = logging.getLogger("TestVolumeDestroyRecover") | |
| cls.stream_handler = logging.StreamHandler() | |
| cls.logger.setLevel(logging.DEBUG) | |
| cls.logger.addHandler(cls.stream_handler) | |
| # Get Domain and templates | |
| cls.domain = get_domain(cls.apiclient) | |
| cls.template = get_template(cls.apiclient, cls.zone.id, hypervisor="KVM") | |
| if cls.template == FAILED: | |
| sys.exit(1) | |
| cls.templatesize = (cls.template.size / (1024 ** 3)) | |
| cls.services['mode'] = cls.zone.networktype | |
| # Create Account | |
| cls.account = Account.create( | |
| cls.apiclient, | |
| cls.services["account"], | |
| admin=True, | |
| domainid=cls.domain.id | |
| ) | |
| cls._cleanup.append(cls.account); | |
| accounts = Account.list(cls.apiclient, id=cls.account.id) | |
| cls.expectedCount = int(accounts[0].primarystoragetotal) | |
| cls.volumeTotal = int(accounts[0].volumetotal) | |
| if cls.zone.securitygroupsenabled: | |
| cls.services["shared_network_offering"]["specifyVlan"] = 'True' | |
| cls.services["shared_network_offering"]["specifyIpRanges"] = 'True' | |
| cls.network_offering = NetworkOffering.create( | |
| cls.apiclient, | |
| cls.services["shared_network_offering"] | |
| ) | |
| cls._cleanup.append(cls.network_offering) | |
| cls.network_offering.update(cls.apiclient, state='Enabled') | |
| cls.account_network = Network.create( | |
| cls.apiclient, | |
| cls.services["network2"], | |
| networkofferingid=cls.network_offering.id, | |
| zoneid=cls.zone.id, | |
| accountid=cls.account.name, | |
| domainid=cls.account.domainid | |
| ) | |
| cls._cleanup.append(cls.account_network) | |
| else: | |
| cls.network_offering = NetworkOffering.create( | |
| cls.apiclient, | |
| cls.services["isolated_network_offering"], | |
| ) | |
| cls._cleanup.append(cls.network_offering) | |
| # Enable Network offering | |
| cls.network_offering.update(cls.apiclient, state='Enabled') | |
| # Create account network | |
| cls.services["network"]["zoneid"] = cls.zone.id | |
| 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._cleanup.append(cls.account_network) | |
| # Create small service offering | |
| cls.service_offering = ServiceOffering.create( | |
| cls.apiclient, | |
| cls.services["service_offerings"]["small"] | |
| ) | |
| cls._cleanup.append(cls.service_offering) | |
| # Create disk offering | |
| cls.disk_offering = DiskOffering.create( | |
| cls.apiclient, | |
| cls.services["disk_offering"], | |
| ) | |
| cls._cleanup.append(cls.disk_offering) | |
| @classmethod | |
| def tearDownClass(cls): | |
| super(TestVolumeDestroyRecover, cls).tearDownClass() | |
| def setUp(self): | |
| self.apiclient = self.testClient.getApiClient() | |
| self.cleanup = [] | |
| return | |
| def tearDown(self): | |
| super(TestVolumeDestroyRecover, self).tearDown() | |
| def verify_resource_count_primary_storage(self, expectedCount, volumeTotal): | |
| response = matchResourceCount( | |
| self.apiclient, expectedCount, | |
| RESOURCE_PRIMARY_STORAGE, | |
| accountid=self.account.id) | |
| self.assertEqual(response[0], PASS, response[1]) | |
| result = isAccountResourceCountEqualToExpectedCount( | |
| self.apiclient, self.account.domainid, self.account.name, | |
| expectedCount, RESOURCE_PRIMARY_STORAGE) | |
| self.assertFalse(result[0], result[1]) | |
| self.assertTrue(result[2], "Resource count of primary storage does not match") | |
| response = matchResourceCount( | |
| self.apiclient, volumeTotal, | |
| RESOURCE_VOLUME, | |
| accountid=self.account.id) | |
| self.assertEqual(response[0], PASS, response[1]) | |
| result = isAccountResourceCountEqualToExpectedCount( | |
| self.apiclient, self.account.domainid, self.account.name, | |
| volumeTotal, RESOURCE_VOLUME) | |
| self.assertFalse(result[0], result[1]) | |
| self.assertTrue(result[2], "Resource count of volume does not match") | |
| @attr(tags=["advanced", "advancedsg"], required_hardware="false") | |
| def test_01_create_vm_with_data_disk(self): | |
| """Create VM with DATA disk, then destroy it (expunge=False) and expunge it | |
| Steps: | |
| # 1. create vm with root disk and data disk | |
| # 2. destroy vm, resource count of primary storage is not changed | |
| # 3. expunge vm, resource count of primary storage decreased with size of root disk. | |
| # 4. delete volume (data disk), resource count of primary storage decreased with size of data disk | |
| """ | |
| try: | |
| virtual_machine_1 = VirtualMachine.create( | |
| self.apiclient, | |
| self.services["virtual_machine"], | |
| accountid=self.account.name, | |
| domainid=self.account.domainid, | |
| serviceofferingid=self.service_offering.id, | |
| diskofferingid=self.disk_offering.id, | |
| templateid=self.template.id, | |
| zoneid=self.zone.id | |
| ) | |
| self.cleanup.append(virtual_machine_1) | |
| except Exception as e: | |
| self.fail("Exception while deploying virtual machine: %s" % e) | |
| self.expectedCount = self.expectedCount + self.templatesize + self.disk_offering.disksize | |
| self.volumeTotal = self.volumeTotal + 2 | |
| self.verify_resource_count_primary_storage(self.expectedCount, self.volumeTotal); | |
| root_volumes_list = Volume.list( | |
| self.apiclient, | |
| virtualmachineid=virtual_machine_1.id, | |
| type='ROOT', | |
| listall=True | |
| ) | |
| status = validateList(root_volumes_list) | |
| self.assertEqual(status[0], PASS, "ROOT Volume List Validation Failed") | |
| root_volume_id = root_volumes_list[0].id | |
| data_volumes_list = Volume.list( | |
| self.apiclient, | |
| virtualmachineid=virtual_machine_1.id, | |
| type='DATADISK', | |
| listall=True | |
| ) | |
| status = validateList(data_volumes_list) | |
| self.assertEqual(status[0], PASS, "DATADISK Volume List Validation Failed") | |
| data_volume_id = data_volumes_list[0].id | |
| # destroy vm | |
| virtual_machine_1.delete(self.apiclient, expunge=False) | |
| self.cleanup.remove(virtual_machine_1) | |
| self.verify_resource_count_primary_storage(self.expectedCount, self.volumeTotal) | |
| # expunge vm | |
| virtual_machine_1.expunge(self.apiclient) | |
| self.expectedCount = self.expectedCount - self.templatesize | |
| self.volumeTotal = self.volumeTotal - 1 | |
| self.verify_resource_count_primary_storage(self.expectedCount, self.volumeTotal) | |
| # delete datadisk | |
| cmd = deleteVolume.deleteVolumeCmd() | |
| cmd.id = data_volume_id | |
| self.apiclient.deleteVolume(cmd) | |
| self.expectedCount = self.expectedCount - self.disk_offering.disksize | |
| self.volumeTotal = self.volumeTotal - 1 | |
| self.verify_resource_count_primary_storage(self.expectedCount, self.volumeTotal) | |
| @attr(tags=["advanced", "advancedsg"], required_hardware="false") | |
| def test_02_destroy_allocated_volume(self): | |
| """Create volume, destroy it when expunge=false and expunge=true | |
| Steps: | |
| # 1. create volume, resource count increases. | |
| # 2. destroy volume (expunge = false), Exception happened. resource count no changes | |
| # 3. destroy volume (expunge = True), resource count of primary storage decreased with size of volume. | |
| """ | |
| # Create volume | |
| volume = Volume.create( | |
| self.apiclient, self.services["volume"], | |
| zoneid=self.zone.id, account=self.account.name, | |
| domainid=self.account.domainid, diskofferingid=self.disk_offering.id | |
| ) | |
| self.cleanup.append(volume) | |
| self.expectedCount = self.expectedCount + self.disk_offering.disksize | |
| self.volumeTotal = self.volumeTotal + 1 | |
| self.verify_resource_count_primary_storage(self.expectedCount, self.volumeTotal); | |
| # Destroy volume (expunge=False) | |
| with self.assertRaises(Exception): | |
| volume.destroy(self.apiclient) | |
| # Destroy volume (expunge=True) | |
| volume.destroy(self.apiclient, expunge=True) | |
| self.cleanup.remove(volume) | |
| self.expectedCount = self.expectedCount - self.disk_offering.disksize | |
| self.volumeTotal = self.volumeTotal - 1 | |
| self.verify_resource_count_primary_storage(self.expectedCount, self.volumeTotal); | |
| @attr(tags=["advanced", "advancedsg"], required_hardware="false") | |
| def test_03_destroy_detached_volume(self): | |
| """Create volume, attach/detach it, then destroy it when expunge=false and expunge=true | |
| Steps: | |
| # 1. create vm without data disk, resource count increases. | |
| # 2. create volume, resource count increases. | |
| # 3. attach volume to a vm. resource count no changes. | |
| # 4. detach volume from a vm. resource count no changes. | |
| # 5. destroy volume (expunge = false), volume is Destroy. resource count decreased with size of volume. | |
| # 6. destroy volume (expunge = true), volume is not found. resource count no changes. | |
| # 7. destroy vm (expunge=True). resource count decreased with size of root disk | |
| """ | |
| # Create vm | |
| try: | |
| virtual_machine_2 = VirtualMachine.create( | |
| self.apiclient, | |
| self.services["virtual_machine"], | |
| accountid=self.account.name, | |
| domainid=self.account.domainid, | |
| serviceofferingid=self.service_offering.id, | |
| templateid=self.template.id, | |
| zoneid=self.zone.id | |
| ) | |
| self.cleanup.append(virtual_machine_2) | |
| except Exception as e: | |
| self.fail("Exception while deploying virtual machine: %s" % e) | |
| self.expectedCount = self.expectedCount + self.templatesize | |
| self.volumeTotal = self.volumeTotal + 1 | |
| self.verify_resource_count_primary_storage(self.expectedCount, self.volumeTotal); | |
| # Create volume | |
| volume = Volume.create( | |
| self.apiclient, self.services["volume"], | |
| zoneid=self.zone.id, account=self.account.name, | |
| domainid=self.account.domainid, diskofferingid=self.disk_offering.id | |
| ) | |
| self.cleanup.append(volume) | |
| self.expectedCount = self.expectedCount + self.disk_offering.disksize | |
| self.volumeTotal = self.volumeTotal + 1 | |
| self.verify_resource_count_primary_storage(self.expectedCount, self.volumeTotal); | |
| # Attach volume to vm | |
| virtual_machine_2.attach_volume(self.apiclient, volume) | |
| self.verify_resource_count_primary_storage(self.expectedCount, self.volumeTotal); | |
| # Detach volume from vm | |
| virtual_machine_2.stop(self.apiclient) | |
| virtual_machine_2.detach_volume(self.apiclient, volume) | |
| self.verify_resource_count_primary_storage(self.expectedCount, self.volumeTotal); | |
| # save id for later recovery and expunge | |
| volumeUuid = volume.id | |
| # Destroy volume (expunge=False) | |
| volume.destroy(self.apiclient, expunge=False) | |
| self.cleanup.remove(volume) | |
| self.expectedCount = self.expectedCount - self.disk_offering.disksize | |
| self.volumeTotal = self.volumeTotal - 1 | |
| self.verify_resource_count_primary_storage(self.expectedCount, self.volumeTotal); | |
| # Destroy volume (expunge=True) | |
| volume.destroy(self.apiclient, expunge=True) | |
| self.verify_resource_count_primary_storage(self.expectedCount, self.volumeTotal); | |
| # Destroy VM (expunge=True) | |
| virtual_machine_2.delete(self.apiclient, expunge=True) | |
| self.cleanup.remove(virtual_machine_2) | |
| self.expectedCount = self.expectedCount - self.templatesize | |
| self.volumeTotal = self.volumeTotal - 1 | |
| self.verify_resource_count_primary_storage(self.expectedCount, self.volumeTotal); | |
| @attr(tags=["advanced", "advancedsg"], required_hardware="false") | |
| def test_04_recover_root_volume_after_restorevm(self): | |
| """Restore VM, recover/delete old root disk | |
| Steps: | |
| # 1. create vm without data disk, resource count increases. | |
| # 2. restore vm. resource count no changes. | |
| # 3. check old root disk , should be Destroy state | |
| # 4. recover old root disk. resource count increases. | |
| # 5. delete old root disk . resource count decreases. | |
| # 6. destroy vm (expunge=True). resource count decreased with size of root disk | |
| """ | |
| # Create vm | |
| try: | |
| virtual_machine_3 = VirtualMachine.create( | |
| self.apiclient, | |
| self.services["virtual_machine"], | |
| accountid=self.account.name, | |
| domainid=self.account.domainid, | |
| serviceofferingid=self.service_offering.id, | |
| templateid=self.template.id, | |
| zoneid=self.zone.id | |
| ) | |
| self.cleanup.append(virtual_machine_3) | |
| except Exception as e: | |
| self.fail("Exception while deploying virtual machine: %s" % e) | |
| self.expectedCount = self.expectedCount + self.templatesize | |
| self.volumeTotal = self.volumeTotal + 1 | |
| self.verify_resource_count_primary_storage(self.expectedCount, self.volumeTotal); | |
| # Get id of root disk | |
| root_volumes_list = Volume.list( | |
| self.apiclient, | |
| virtualmachineid=virtual_machine_3.id, | |
| type='ROOT', | |
| listall=True | |
| ) | |
| status = validateList(root_volumes_list) | |
| self.assertEqual(status[0], PASS, "ROOT Volume List Validation Failed") | |
| root_volume_id = root_volumes_list[0].id | |
| # restore vm | |
| virtual_machine_3.restore(self.apiclient) | |
| self.verify_resource_count_primary_storage(self.expectedCount, self.volumeTotal); | |
| # check old root disk state | |
| root_volumes_list = Volume.list( | |
| self.apiclient, | |
| id=root_volume_id, | |
| listall=True | |
| ) | |
| status = validateList(root_volumes_list) | |
| self.assertEqual(status[0], PASS, "ROOT Volume List Validation Failed") | |
| root_volume = root_volumes_list[0] | |
| self.assertEqual(root_volume['state'], 'Destroy', "ROOT volume should be Destroy after restorevm") | |
| # recover old root disk | |
| cmd = recoverVolume.recoverVolumeCmd() | |
| cmd.id = root_volume.id | |
| self.apiclient.recoverVolume(cmd) | |
| self.expectedCount = self.expectedCount + self.templatesize | |
| self.volumeTotal = self.volumeTotal + 1 | |
| self.verify_resource_count_primary_storage(self.expectedCount, self.volumeTotal); | |
| # delete old root disk | |
| cmd = deleteVolume.deleteVolumeCmd() | |
| cmd.id = root_volume.id | |
| self.apiclient.deleteVolume(cmd) | |
| self.expectedCount = self.expectedCount - self.templatesize | |
| self.volumeTotal = self.volumeTotal - 1 | |
| self.verify_resource_count_primary_storage(self.expectedCount, self.volumeTotal) | |
| # Destroy VM (expunge=True) | |
| virtual_machine_3.delete(self.apiclient, expunge=True) | |
| self.cleanup.remove(virtual_machine_3) | |
| self.expectedCount = self.expectedCount - self.templatesize | |
| self.volumeTotal = self.volumeTotal - 1 | |
| self.verify_resource_count_primary_storage(self.expectedCount, self.volumeTotal); | |
| @attr(tags=["advanced", "advancedsg"], required_hardware="false") | |
| def test_05_extract_root_volume_and_destroy_vm(self): | |
| """Create VM, extract root volume, then destroy vm and volume | |
| Steps: | |
| # 1. create vm without data disk, resource count increases. | |
| # 2. stop vm | |
| # 3. extract root volume | |
| # 4. expunge vm, root volume in Expunged state. resource count decreased with size of root disk. | |
| # 5. destroy volume (expunge = false), Exception happened. resource count no changes | |
| # 6. destroy volume (expunge = true). volume is not found. resource count no changes. | |
| """ | |
| # Create vm | |
| try: | |
| virtual_machine_4 = VirtualMachine.create( | |
| self.apiclient, | |
| self.services["virtual_machine"], | |
| accountid=self.account.name, | |
| domainid=self.account.domainid, | |
| serviceofferingid=self.service_offering.id, | |
| templateid=self.template.id, | |
| zoneid=self.zone.id | |
| ) | |
| self.cleanup.append(virtual_machine_4) | |
| except Exception as e: | |
| self.fail("Exception while deploying virtual machine: %s" % e) | |
| self.expectedCount = self.expectedCount + self.templatesize | |
| self.volumeTotal = self.volumeTotal + 1 | |
| self.verify_resource_count_primary_storage(self.expectedCount, self.volumeTotal); | |
| # Get id of root disk | |
| root_volumes_list = Volume.list( | |
| self.apiclient, | |
| virtualmachineid=virtual_machine_4.id, | |
| type='ROOT', | |
| listall=True | |
| ) | |
| status = validateList(root_volumes_list) | |
| self.assertEqual(status[0], PASS, "ROOT Volume List Validation Failed") | |
| root_volume_id = root_volumes_list[0].id | |
| # Stop vm | |
| virtual_machine_4.stop(self.apiclient) | |
| # extract root volume | |
| cmd = extractVolume.extractVolumeCmd() | |
| cmd.id = root_volume_id | |
| cmd.mode = "HTTP_DOWNLOAD" | |
| cmd.zoneid = self.zone.id | |
| self.apiclient.extractVolume(cmd) | |
| # Destroy VM (expunge=True) | |
| virtual_machine_4.delete(self.apiclient, expunge=True) | |
| self.cleanup.remove(virtual_machine_4) | |
| self.expectedCount = self.expectedCount - self.templatesize | |
| self.volumeTotal = self.volumeTotal - 1 | |
| self.verify_resource_count_primary_storage(self.expectedCount, self.volumeTotal); | |
| # check root disk state | |
| root_volumes_list = Volume.list( | |
| self.apiclient, | |
| id=root_volume_id, | |
| listall=True | |
| ) | |
| status = validateList(root_volumes_list) | |
| self.assertEqual(status[0], PASS, "ROOT Volume List Validation Failed") | |
| root_volume = root_volumes_list[0] | |
| self.assertEqual(root_volume['state'], 'Expunged', "ROOT volume should be Destroy after restorevm") | |
| # delete root disk | |
| cmd = deleteVolume.deleteVolumeCmd() | |
| cmd.id = root_volume.id | |
| self.apiclient.deleteVolume(cmd) | |
| self.verify_resource_count_primary_storage(self.expectedCount, self.volumeTotal) | |
| @attr(tags=["advanced", "advancedsg"], required_hardware="false") | |
| def test_06_delete_network(self): | |
| """Delete account network, resource count should not be changed | |
| Steps: | |
| # 1. Delete account network | |
| # 2. resource count should not be changed | |
| """ | |
| self.account_network.delete(self.apiclient) | |
| self._cleanup.remove(self.account_network) | |
| self.verify_resource_count_primary_storage(self.expectedCount, self.volumeTotal) |