apache/cloudstack
1
0
Fork 0
mirror of https://github.com/apache/cloudstack.git synced 2025-10-26 08:42:29 +01:00
Code Issues Packages Projects Releases Wiki Activity
cloudstack/test/integration/plugins/solidfire/TestVMSnapshots.py
Mike Tutkowski a30a31c9b7 CLOUDSTACK-9620: Enhancements for managed storage (#2298) 
Allowed zone-wide primary storage based on a custom plug-in to be added via the GUI in a KVM-only environment (previously this only worked for XenServer and VMware)

Added support for root disks on managed storage with KVM

Added support for volume snapshots with managed storage on KVM

Enable creating a template directly from a volume (i.e. without having to go through a volume snapshot) on KVM with managed storage

Only allow the resizing of a volume for managed storage on KVM if the volume in question is either not attached to a VM or is attached to a VM in the Stopped state.

Included support for Reinstall VM on KVM with managed storage

Enabled offline migration on KVM from non-managed storage to managed storage and vice versa

Included support for online storage migration on KVM with managed storage (NFS and Ceph to managed storage)

Added support to download (extract) a managed-storage volume to a QCOW2 file

When uploading a file from outside of CloudStack to CloudStack, set the min and max IOPS, if applicable.

Included support for the KVM auto-convergence feature

The compression flag was actually added in version 1.0.3 (1000003) as opposed to version 1.3.0 (1003000) (changed this to reflect the correct version)

On KVM when using iSCSI-based managed storage, if the user shuts a VM down from the guest OS (as opposed to doing so from CloudStack), we need to pass to the KVM agent a list of applicable iSCSI volumes that need to be disconnected.

Added a new Global Setting: kvm.storage.live.migration.wait

For XenServer, added a check to enforce that only volumes from zone-wide managed storage can be storage motioned from a host in one cluster to a host in another cluster (cannot do so at the time being with volumes from cluster-scoped managed storage)

Don’t allow Storage XenMotion on a VM that has any managed-storage volume with one or more snapshots.

Enabled for managed storage with VMware: Template caching, create snapshot, delete snapshot, create volume from snapshot, and create template from snapshot

Added an SIOC API plug-in to support VMware SIOC

When starting a VM that uses managed storage in a cluster other than the one it last was running in, we need to remove the reference to the iSCSI volume from the original cluster.

Added the ability to revert a volume to a snapshot

Enabled cluster-scoped managed storage

Added support for VMware dynamic discovery
2018-01-15 00:05:52 +05:30

780 lines
27 KiB
Python
Raw Blame History

# 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.
import logging
import random
import SignedAPICall
import time
import XenAPI
from solidfire.factory import ElementFactory
from util import sf_util
# All tests inherit from cloudstackTestCase
from marvin.cloudstackTestCase import cloudstackTestCase
# Import Integration Libraries
# base - contains all resources as entities and defines create, delete, list operations on them
from marvin.lib.base import Account, DiskOffering, ServiceOffering, StoragePool, User, VirtualMachine, VmSnapshot, Volume
# common - commonly used methods for all tests are listed here
from marvin.lib.common import get_domain, get_template, get_zone, list_hosts, list_volumes
# utils - utility classes for common cleanup, external library wrappers, etc.
from marvin.lib.utils import cleanup_resources
# Prerequisites:
# Only one zone
# Only one pod
# Only one cluster
class TestData:
account = "account"
capacityBytes = "capacitybytes"
capacityIops = "capacityiops"
clusterId = "clusterId"
computeOffering = "computeoffering"
diskOffering = "diskoffering"
domainId = "domainId"
hypervisor = "hypervisor"
login = "login"
mvip = "mvip"
password = "password"
port = "port"
primaryStorage = "primarystorage"
provider = "provider"
scope = "scope"
solidFire = "solidfire"
storageTag = "SolidFire_SAN_1"
tags = "tags"
url = "url"
user = "user"
username = "username"
virtualMachine = "virtualmachine"
volume_1 = "volume_1"
xenServer = "xenserver"
zoneId = "zoneId"
# modify to control which hypervisor type to test
hypervisor_type = xenServer
def __init__(self):
self.testdata = {
TestData.solidFire: {
TestData.mvip: "10.117.40.120",
TestData.username: "admin",
TestData.password: "admin",
TestData.port: 443,
TestData.url: "https://10.117.40.120:443"
},
TestData.xenServer: {
TestData.username: "root",
TestData.password: "solidfire"
},
TestData.account: {
"email": "test@test.com",
"firstname": "John",
"lastname": "Doe",
TestData.username: "test",
TestData.password: "test"
},
TestData.user: {
"email": "user@test.com",
"firstname": "Jane",
"lastname": "Doe",
TestData.username: "testuser",
TestData.password: "password"
},
TestData.primaryStorage: {
"name": "SolidFire-%d" % random.randint(0, 100),
TestData.scope: "ZONE",
"url": "MVIP=10.117.40.120;SVIP=10.117.41.120;" +
"clusterAdminUsername=admin;clusterAdminPassword=admin;" +
"clusterDefaultMinIops=10000;clusterDefaultMaxIops=15000;" +
"clusterDefaultBurstIopsPercentOfMaxIops=1.5;",
TestData.provider: "SolidFire",
TestData.tags: TestData.storageTag,
TestData.capacityIops: 4500000,
TestData.capacityBytes: 2251799813685248,
TestData.hypervisor: "Any"
},
TestData.virtualMachine: {
"name": "TestVM",
"displayname": "Test VM"
},
TestData.computeOffering: {
"name": "SF_CO_1",
"displaytext": "SF_CO_1 (Min IOPS = 10,000; Max IOPS = 15,000)",
"cpunumber": 1,
"cpuspeed": 100,
"memory": 128,
"storagetype": "shared",
"customizediops": False,
"miniops": "10000",
"maxiops": "15000",
"hypervisorsnapshotreserve": 200,
TestData.tags: TestData.storageTag
},
TestData.diskOffering: {
"name": "SF_DO_1",
"displaytext": "SF_DO_1 (Min IOPS = 300; Max IOPS = 500)",
"disksize": 128,
"customizediops": False,
"miniops": 300,
"maxiops": 500,
"hypervisorsnapshotreserve": 200,
TestData.tags: TestData.storageTag,
"storagetype": "shared"
},
TestData.volume_1: {
"diskname": "testvolume",
},
TestData.zoneId: 1,
TestData.clusterId: 1,
TestData.domainId: 1,
TestData.url: "10.117.40.114"
}
class TestVMSnapshots(cloudstackTestCase):
_should_be_no_vm_snapshots_err_msg = "There should be no VM snapshots."
_should_only_be_one_vm_snapshot_err_msg = "There should only be one VM snapshot."
_should_only_be_one_root_volume_err_msg = "There should only be one root volume."
_path_should_have_changed_err_msg = "The 'path' in the 'DB' should have changed."
_path_should_not_have_changed_err_msg = "The 'path' in the 'DB' should not have changed."
_should_only_be_one_vdi_err_msg = "There should only be one VDI."
_should_be_three_vdis_err_msg = "There should be three VDIs."
_active_vdis_should_not_be_the_same_err_msg = "The active VDIs should not be the same."
_active_vdis_should_be_the_same_err_msg = "The active VDIs should be the same."
_snapshot_vdis_should_be_the_same_err_msg = "The snapshot VDIs should be the same."
_base_vdis_should_be_the_same_err_msg = "The base VDIs should be the same."
_snapshot_parent_not_correct_err_msg = "Snapshot's parent is not correct."
@classmethod
def setUpClass(cls):
# Set up API client
testclient = super(TestVMSnapshots, cls).getClsTestClient()
cls.apiClient = testclient.getApiClient()
cls.configData = testclient.getParsedTestDataConfig()
cls.testdata = TestData().testdata
# Set up XenAPI connection
host_ip = "https://" + \
list_hosts(cls.apiClient, clusterid=cls.testdata[TestData.clusterId], name="XenServer-6.5-1")[0].ipaddress
cls.xen_session = XenAPI.Session(host_ip)
xenserver = cls.testdata[TestData.xenServer]
cls.xen_session.xenapi.login_with_password(xenserver[TestData.username], xenserver[TestData.password])
# Set up SolidFire connection
solidfire = cls.testdata[TestData.solidFire]
cls.sfe = ElementFactory.create(solidfire[TestData.mvip], solidfire[TestData.username], solidfire[TestData.password])
# Get Resources from Cloud Infrastructure
cls.zone = get_zone(cls.apiClient, zone_id=cls.testdata[TestData.zoneId])
template = get_template(cls.apiClient, cls.zone.id, hypervisor=TestData.hypervisor_type)
cls.domain = get_domain(cls.apiClient, cls.testdata[TestData.domainId])
# Create test account
cls.account = Account.create(
cls.apiClient,
cls.testdata[TestData.account],
admin=1
)
# Set up connection to make customized API calls
user = User.create(
cls.apiClient,
cls.testdata[TestData.user],
account=cls.account.name,
domainid=cls.domain.id
)
url = cls.testdata[TestData.url]
api_url = "http://" + url + ":8080/client/api"
userkeys = User.registerUserKeys(cls.apiClient, user.id)
cls.cs_api = SignedAPICall.CloudStack(api_url, userkeys.apikey, userkeys.secretkey)
primarystorage = cls.testdata[TestData.primaryStorage]
cls.primary_storage = StoragePool.create(
cls.apiClient,
primarystorage,
scope=primarystorage[TestData.scope],
zoneid=cls.zone.id,
provider=primarystorage[TestData.provider],
tags=primarystorage[TestData.tags],
capacityiops=primarystorage[TestData.capacityIops],
capacitybytes=primarystorage[TestData.capacityBytes],
hypervisor=primarystorage[TestData.hypervisor]
)
compute_offering = ServiceOffering.create(
cls.apiClient,
cls.testdata[TestData.computeOffering]
)
cls.disk_offering = DiskOffering.create(
cls.apiClient,
cls.testdata[TestData.diskOffering]
)
# Create VM and volume for tests
cls.virtual_machine = VirtualMachine.create(
cls.apiClient,
cls.testdata[TestData.virtualMachine],
accountid=cls.account.name,
zoneid=cls.zone.id,
serviceofferingid=compute_offering.id,
templateid=template.id,
domainid=cls.domain.id,
startvm=True
)
cls._cleanup = [
compute_offering,
cls.disk_offering,
user,
cls.account
]
@classmethod
def tearDownClass(cls):
try:
time.sleep(60)
cls.virtual_machine.delete(cls.apiClient, True)
cleanup_resources(cls.apiClient, cls._cleanup)
cls.primary_storage.delete(cls.apiClient)
sf_util.purge_solidfire_volumes(cls.sfe)
except Exception as e:
logging.debug("Exception in tearDownClass(cls): %s" % e)
def setUp(self):
self.cleanup = []
def tearDown(self):
try:
cleanup_resources(self.apiClient, self.cleanup)
except Exception as e:
logging.debug("Exception in tearDown(self): %s" % e)
def test_01_take_VM_snapshot(self):
self.virtual_machine.start(self.apiClient)
root_volumes = list_volumes(self.apiClient, type="ROOT", listAll="true")
sf_util.check_list(root_volumes, 1, self, TestVMSnapshots._should_only_be_one_root_volume_err_msg)
root_volume = root_volumes[0]
volume_id = {'volumeid': root_volume.id}
sf_iscsi_name_result = self.cs_api.getVolumeiScsiName(volume_id)
sf_iscsi_name = sf_iscsi_name_result['apivolumeiscsiname']['volumeiScsiName']
sf_util.check_iscsi_name(sf_iscsi_name, self)
root_volume_path_1 = self._get_path(volume_id)
#######################################
#######################################
# STEP 1: Take snapshot of running VM #
#######################################
#######################################
vm_snapshot = VmSnapshot.create(
self.apiClient,
vmid=self.virtual_machine.id,
snapshotmemory="false",
name="Test Snapshot",
description="Test Snapshot Desc"
)
list_vm_snapshots = VmSnapshot.list(self.apiClient, listAll="true")
self._verify_vm_snapshot(list_vm_snapshots, vm_snapshot)
root_volume_path_2 = self._get_path(volume_id)
self.assertEqual(
root_volume_path_1,
root_volume_path_2,
TestVMSnapshots._path_should_not_have_changed_err_msg
)
xen_sr = self.xen_session.xenapi.SR.get_by_name_label(sf_iscsi_name)[0]
xen_vdis = self.xen_session.xenapi.SR.get_VDIs(xen_sr)
sf_util.check_list(xen_vdis, 3, self, TestVMSnapshots._should_be_three_vdis_err_msg)
vdis_after_create = self._get_vdis(xen_vdis)
vdiSnapshotOf = self.xen_session.xenapi.VDI.get_record(vdis_after_create.snapshot_vdi["snapshot_of"])
self.assertEqual(
vdiSnapshotOf["uuid"],
vdis_after_create.active_vdi["uuid"],
TestVMSnapshots._snapshot_parent_not_correct_err_msg
)
#######################################
#######################################
### STEP 2: Revert VM to Snapshot ###
#######################################
#######################################
self.virtual_machine.stop(self.apiClient)
VmSnapshot.revertToSnapshot(self.apiClient, vmsnapshotid=vm_snapshot.id)
list_vm_snapshots = VmSnapshot.list(self.apiClient, listAll="true")
sf_util.check_list(list_vm_snapshots, 1, self, TestVMSnapshots._should_only_be_one_vm_snapshot_err_msg)
root_volume_path_3 = self._get_path(volume_id)
self.assertNotEqual(
root_volume_path_1,
root_volume_path_3,
TestVMSnapshots._path_should_have_changed_err_msg
)
xen_vdis = self.xen_session.xenapi.SR.get_VDIs(xen_sr)
sf_util.check_list(xen_vdis, 3, self, TestVMSnapshots._should_be_three_vdis_err_msg)
vdis_after_revert = self._get_vdis(xen_vdis)
self.assertNotEqual(
vdis_after_create.active_vdi["uuid"],
vdis_after_revert.active_vdi["uuid"],
TestVMSnapshots._active_vdis_should_not_be_the_same_err_msg
)
self.assertEqual(
vdis_after_create.snapshot_vdi["uuid"],
vdis_after_revert.snapshot_vdi["uuid"],
TestVMSnapshots._snapshot_vdis_should_be_the_same_err_msg
)
self.assertEqual(
vdis_after_create.base_vdi["uuid"],
vdis_after_revert.base_vdi["uuid"],
TestVMSnapshots._base_vdis_should_be_the_same_err_msg
)
#######################################
#######################################
##### STEP 3: Delete VM snapshot #####
#######################################
#######################################
VmSnapshot.deleteVMSnapshot(self.apiClient, vmsnapshotid=vm_snapshot.id)
list_vm_snapshots = VmSnapshot.list(self.apiClient, listAll="true")
self.assertEqual(
list_vm_snapshots,
None,
TestVMSnapshots._should_be_no_vm_snapshots_err_msg
)
root_volume_path_4 = self._get_path(volume_id)
self.assertEqual(
root_volume_path_3,
root_volume_path_4,
TestVMSnapshots._path_should_not_have_changed_err_msg
)
xen_vdis = self.xen_session.xenapi.SR.get_VDIs(xen_sr)
sf_util.check_list(xen_vdis, 1, self, TestVMSnapshots._should_only_be_one_vdi_err_msg)
vdis_after_delete = self._get_vdis(xen_vdis, True)
self.assertEqual(
vdis_after_revert.active_vdi["uuid"],
vdis_after_delete.active_vdi["uuid"],
TestVMSnapshots._active_vdis_should_be_the_same_err_msg
)
#######################################
#######################################
##### STEP 4: Start VM #####
#######################################
#######################################
self.virtual_machine.start(self.apiClient)
def test_02_take_VM_snapshot_with_data_disk(self):
self.virtual_machine.start(self.apiClient)
data_volume = Volume.create(
self.apiClient,
self.testdata[TestData.volume_1],
account=self.account.name,
domainid=self.domain.id,
zoneid=self.zone.id,
diskofferingid=self.disk_offering.id
)
self.cleanup = [data_volume]
self.virtual_machine.attach_volume(self.apiClient, data_volume)
root_volumes = list_volumes(self.apiClient, type="ROOT", listAll="true")
sf_util.check_list(root_volumes, 1, self, TestVMSnapshots._should_only_be_one_root_volume_err_msg)
root_volume = root_volumes[0]
root_volume_id = {'volumeid': root_volume.id}
sf_iscsi_name_result = self.cs_api.getVolumeiScsiName(root_volume_id)
sf_iscsi_root_volume_name = sf_iscsi_name_result['apivolumeiscsiname']['volumeiScsiName']
sf_util.check_iscsi_name(sf_iscsi_root_volume_name, self)
root_volume_path_1 = self._get_path(root_volume_id)
data_volumes = list_volumes(self.apiClient, type="DATADISK", listAll="true")
sf_util.check_list(data_volumes, 1, self, "There should only be one data volume.")
data_volume = data_volumes[0]
data_volume_id = {'volumeid': data_volume.id}
sf_iscsi_name_result = self.cs_api.getVolumeiScsiName(data_volume_id)
sf_iscsi_data_volume_name = sf_iscsi_name_result['apivolumeiscsiname']['volumeiScsiName']
sf_util.check_iscsi_name(sf_iscsi_data_volume_name, self)
data_volume_path_1 = self._get_path(data_volume_id)
#######################################
#######################################
# STEP 1: Take snapshot of running VM #
#######################################
#######################################
vm_snapshot = VmSnapshot.create(
self.apiClient,
vmid=self.virtual_machine.id,
snapshotmemory="false",
name="Test Snapshot",
description="Test Snapshot Desc"
)
list_vm_snapshots = VmSnapshot.list(self.apiClient, listAll="true")
self._verify_vm_snapshot(list_vm_snapshots, vm_snapshot)
root_volume_path_2 = self._get_path(root_volume_id)
self.assertEqual(
root_volume_path_1,
root_volume_path_2,
TestVMSnapshots._path_should_not_have_changed_err_msg
)
data_volume_path_2 = self._get_path(data_volume_id)
self.assertEqual(
data_volume_path_1,
data_volume_path_2,
TestVMSnapshots._path_should_not_have_changed_err_msg
)
root_volume_xen_sr = self.xen_session.xenapi.SR.get_by_name_label(sf_iscsi_root_volume_name)[0]
root_volume_xen_vdis = self.xen_session.xenapi.SR.get_VDIs(root_volume_xen_sr)
sf_util.check_list(root_volume_xen_vdis, 3, self, TestVMSnapshots._should_be_three_vdis_err_msg)
root_volume_vdis_after_create = self._get_vdis(root_volume_xen_vdis)
vdiSnapshotOf = self.xen_session.xenapi.VDI.get_record(root_volume_vdis_after_create.snapshot_vdi["snapshot_of"])
self.assertEqual(
vdiSnapshotOf["uuid"],
root_volume_vdis_after_create.active_vdi["uuid"],
TestVMSnapshots._snapshot_parent_not_correct_err_msg
)
data_volume_xen_sr = self.xen_session.xenapi.SR.get_by_name_label(sf_iscsi_data_volume_name)[0]
data_volume_xen_vdis = self.xen_session.xenapi.SR.get_VDIs(data_volume_xen_sr)
sf_util.check_list(data_volume_xen_vdis, 3, self, TestVMSnapshots._should_be_three_vdis_err_msg)
data_volume_vdis_after_create = self._get_vdis(data_volume_xen_vdis)
vdiSnapshotOf = self.xen_session.xenapi.VDI.get_record(data_volume_vdis_after_create.snapshot_vdi["snapshot_of"])
self.assertEqual(
vdiSnapshotOf["uuid"],
data_volume_vdis_after_create.active_vdi["uuid"],
TestVMSnapshots._snapshot_parent_not_correct_err_msg
)
#######################################
#######################################
### STEP 2: Revert VM to Snapshot ###
#######################################
#######################################
self.virtual_machine.stop(self.apiClient)
VmSnapshot.revertToSnapshot(self.apiClient, vmsnapshotid=vm_snapshot.id)
list_vm_snapshots = VmSnapshot.list(self.apiClient, listAll="true")
sf_util.check_list(list_vm_snapshots, 1, self, TestVMSnapshots._should_only_be_one_vm_snapshot_err_msg)
root_volume_path_3 = self._get_path(root_volume_id)
self.assertNotEqual(
root_volume_path_1,
root_volume_path_3,
TestVMSnapshots._path_should_have_changed_err_msg
)
root_volume_xen_vdis = self.xen_session.xenapi.SR.get_VDIs(root_volume_xen_sr)
sf_util.check_list(root_volume_xen_vdis, 3, self, TestVMSnapshots._should_be_three_vdis_err_msg)
root_volume_vdis_after_revert = self._get_vdis(root_volume_xen_vdis)
self.assertNotEqual(
root_volume_vdis_after_create.active_vdi["uuid"],
root_volume_vdis_after_revert.active_vdi["uuid"],
TestVMSnapshots._active_vdis_should_not_be_the_same_err_msg
)
self.assertEqual(
root_volume_vdis_after_create.snapshot_vdi["uuid"],
root_volume_vdis_after_revert.snapshot_vdi["uuid"],
TestVMSnapshots._snapshot_vdis_should_be_the_same_err_msg
)
self.assertEqual(
root_volume_vdis_after_create.base_vdi["uuid"],
root_volume_vdis_after_revert.base_vdi["uuid"],
TestVMSnapshots._base_vdis_should_be_the_same_err_msg
)
data_volume_path_3 = self._get_path(data_volume_id)
self.assertNotEqual(
data_volume_path_1,
data_volume_path_3,
TestVMSnapshots._path_should_have_changed_err_msg
)
data_volume_xen_vdis = self.xen_session.xenapi.SR.get_VDIs(data_volume_xen_sr)
sf_util.check_list(data_volume_xen_vdis, 3, self, TestVMSnapshots._should_be_three_vdis_err_msg)
data_volume_vdis_after_revert = self._get_vdis(data_volume_xen_vdis)
self.assertNotEqual(
data_volume_vdis_after_create.active_vdi["uuid"],
data_volume_vdis_after_revert.active_vdi["uuid"],
TestVMSnapshots._active_vdis_should_not_be_the_same_err_msg
)
self.assertEqual(
data_volume_vdis_after_create.snapshot_vdi["uuid"],
data_volume_vdis_after_revert.snapshot_vdi["uuid"],
TestVMSnapshots._snapshot_vdis_should_be_the_same_err_msg
)
self.assertEqual(
data_volume_vdis_after_create.base_vdi["uuid"],
data_volume_vdis_after_revert.base_vdi["uuid"],
TestVMSnapshots._base_vdis_should_be_the_same_err_msg
)
#######################################
#######################################
##### STEP 3: Delete VM snapshot #####
#######################################
#######################################
VmSnapshot.deleteVMSnapshot(self.apiClient, vmsnapshotid=vm_snapshot.id)
list_vm_snapshots = VmSnapshot.list(self.apiClient, listAll="true")
self.assertEqual(
list_vm_snapshots,
None,
TestVMSnapshots._should_be_no_vm_snapshots_err_msg
)
root_volume_path_4 = self._get_path(root_volume_id)
self.assertEqual(
root_volume_path_3,
root_volume_path_4,
TestVMSnapshots._path_should_not_have_changed_err_msg
)
root_volume_xen_vdis = self.xen_session.xenapi.SR.get_VDIs(root_volume_xen_sr)
sf_util.check_list(root_volume_xen_vdis, 1, self, TestVMSnapshots._should_only_be_one_vdi_err_msg)
root_volume_vdis_after_delete = self._get_vdis(root_volume_xen_vdis, True)
self.assertEqual(
root_volume_vdis_after_revert.active_vdi["uuid"],
root_volume_vdis_after_delete.active_vdi["uuid"],
TestVMSnapshots._active_vdis_should_be_the_same_err_msg
)
data_volume_path_4 = self._get_path(data_volume_id)
self.assertEqual(
data_volume_path_3,
data_volume_path_4,
TestVMSnapshots._path_should_not_have_changed_err_msg
)
data_volume_xen_vdis = self.xen_session.xenapi.SR.get_VDIs(data_volume_xen_sr)
sf_util.check_list(data_volume_xen_vdis, 1, self, TestVMSnapshots._should_only_be_one_vdi_err_msg)
data_volume_vdis_after_delete = self._get_vdis(data_volume_xen_vdis, True)
self.assertEqual(
data_volume_vdis_after_revert.active_vdi["uuid"],
data_volume_vdis_after_delete.active_vdi["uuid"],
TestVMSnapshots._active_vdis_should_be_the_same_err_msg
)
#######################################
#######################################
##### STEP 4: Start VM #####
#######################################
#######################################
self.virtual_machine.detach_volume(self.apiClient, data_volume)
self.virtual_machine.start(self.apiClient)
def _get_path(self, volume_id):
path_result = self.cs_api.getPathForVolume(volume_id)
return path_result['apipathforvolume']['path']
def _verify_vm_snapshot(self, list_vm_snapshots, vm_snapshot):
sf_util.check_list(list_vm_snapshots, 1, self, TestVMSnapshots._should_only_be_one_vm_snapshot_err_msg)
vm_snapshot_from_list = list_vm_snapshots[0]
self.assertEqual(
vm_snapshot.id,
vm_snapshot_from_list.id,
"There is a problem with the VM snapshot ID."
)
self.assertEqual(
vm_snapshot.virtualmachineid,
self.virtual_machine.id,
"The ID of the snapshot's virtual machine does not match the expected virtual machine."
)
self.assertEqual(
vm_snapshot.state,
"Ready",
"The snapshot is not in the 'Ready' state."
)
def _get_vdis(self, xen_vdis, only_active_expected=False):
expected_number_of_vdis = 1 if only_active_expected else 3
self.assertEqual(
len(xen_vdis),
expected_number_of_vdis,
"The list had an unexpected number of items in it."
)
active_vdi = None
snapshot_vdi = None
base_vdi = None
for temp_vdi in xen_vdis:
temp = self.xen_session.xenapi.VDI.get_record(temp_vdi)
if temp["name_label"] == "base copy":
base_vdi = temp
else:
if temp["is_a_snapshot"] == True:
snapshot_vdi = temp
else:
active_vdi = temp
self.assertNotEqual(
active_vdi,
None,
"The active VDI could not be located."
)
if only_active_expected:
self.assertEqual(
snapshot_vdi,
None,
"The snapshot VDI should not be present."
)
self.assertEqual(
base_vdi,
None,
"The base VDI should not be present."
)
else:
self.assertNotEqual(
snapshot_vdi,
None,
"The snapshot VDI could not be located."
)
self.assertNotEqual(
base_vdi,
None,
"The base VDI could not be located."
)
class VdiCollection(object):
pass
vdis = VdiCollection()
vdis.active_vdi = active_vdi
vdis.snapshot_vdi = snapshot_vdi
vdis.base_vdi = base_vdi
return vdis
Reference in New Issue View Git Blame Copy Permalink