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/TestManagedSystemVMs.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

628 lines
24 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 XenAPI
from solidfire.factory import ElementFactory
from util import sf_util
from marvin.cloudstackAPI import destroySystemVm
# 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, Router, ServiceOffering, StoragePool, User, VirtualMachine, Zone
# common - commonly used methods for all tests are listed here
from marvin.lib.common import get_domain, get_template, get_zone, list_clusters, list_hosts, list_ssvms, list_routers
# utils - utility classes for common cleanup, external library wrappers, etc.
from marvin.lib.utils import cleanup_resources, wait_until
# Prerequisites:
# * Only use one SolidFire cluster for the two primary storages based on the "SolidFire" storage plug-in.
# * Do not run other workloads on the SolidFire cluster while running this test as this test checks at a certain
# point to make sure no active SolidFire volumes exist.
# * Only one zone
# * Only one secondary storage VM and one console proxy VM running on NFS (no virtual router or user VMs exist)
# * Only one pod
# * Only one cluster
#
# Running the tests:
# Change the "hypervisor_type" variable to control which hypervisor type to test.
# If using XenServer, verify the "xen_server_hostname" variable is correct.
# Set the Global Setting "storage.cleanup.enabled" to true.
# Set the Global Setting "storage.cleanup.interval" to 150.
# Set the Global Setting "storage.cleanup.delay" to 60.
class TestData():
# constants
account = "account"
capacityBytes = "capacitybytes"
capacityIops = "capacityiops"
clusterId = "clusterid"
computeOffering = "computeoffering"
diskOffering = "diskoffering"
domainId = "domainid"
email = "email"
firstname = "firstname"
hypervisor = "hypervisor"
kvm = "kvm"
lastname = "lastname"
max_iops = "maxiops"
min_iops = "miniops"
mvip = "mvip"
name = "name"
password = "password"
port = "port"
primaryStorage = "primarystorage"
provider = "provider"
scope = "scope"
solidFire = "solidfire"
storageTag = "SolidFire_SAN_1"
systemOffering = "systemoffering"
systemOfferingFailure = "systemofferingFailure"
tags = "tags"
url = "url"
user = "user"
username = "username"
virtualMachine = "virtualmachine"
xenServer = "xenserver"
zoneId = "zoneid"
# modify to control which hypervisor type to test
hypervisor_type = xenServer
xen_server_hostname = "XenServer-6.5-1"
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.kvm: {
TestData.username: "root",
TestData.password: "solidfire"
},
TestData.xenServer: {
TestData.username: "root",
TestData.password: "solidfire"
},
TestData.account: {
TestData.email: "test@test.com",
TestData.firstname: "John",
TestData.lastname: "Doe",
TestData.username: "test",
TestData.password: "test"
},
TestData.user: {
TestData.email: "user@test.com",
TestData.firstname: "Jane",
TestData.lastname: "Doe",
TestData.username: "testuser",
TestData.password: "password"
},
TestData.primaryStorage: {
TestData.name: TestData.get_name_for_solidfire_storage(),
TestData.scope: "ZONE",
TestData.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.zoneId: 1
},
TestData.virtualMachine: {
TestData.name: "TestVM",
"displayname": "Test VM"
},
TestData.computeOffering: {
TestData.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,
TestData.min_iops: 10000,
TestData.max_iops: 15000,
"hypervisorsnapshotreserve": 200,
TestData.tags: TestData.storageTag
},
TestData.systemOffering: {
TestData.name: "SF_SO_1",
"displaytext": "Managed SO (Min IOPS = 4,000; Max IOPS = 8,000)",
"cpunumber": 1,
"cpuspeed": 100,
"memory": 128,
"storagetype": "shared",
TestData.min_iops: 4000,
TestData.max_iops: 8000,
TestData.tags: TestData.storageTag,
"issystem": True
},
TestData.systemOfferingFailure: {
TestData.name: "SF_SO_2",
"displaytext": "Managed SO (Customized IOPS)",
"cpunumber": 1,
"cpuspeed": 100,
"memory": 128,
"storagetype": "shared",
"customizediops": True,
TestData.tags: TestData.storageTag,
"issystem": True
},
TestData.zoneId: 1,
TestData.clusterId: 1,
TestData.domainId: 1,
TestData.url: "10.117.40.114"
}
@staticmethod
def get_name_for_solidfire_storage():
return "SolidFire-%d" % random.randint(0, 100)
class TestManagedSystemVMs(cloudstackTestCase):
_unique_name_suffix = "-Temp"
_secondary_storage_unique_name = "Cloud.com-SecondaryStorage"
_secondary_storage_temp_unique_name = _secondary_storage_unique_name + _unique_name_suffix
_console_proxy_unique_name = "Cloud.com-ConsoleProxy"
_console_proxy_temp_unique_name = _console_proxy_unique_name + _unique_name_suffix
_virtual_router_unique_name = "Cloud.com-SoftwareRouter"
_virtual_router_temp_unique_name = _virtual_router_unique_name + _unique_name_suffix
@classmethod
def setUpClass(cls):
# Set up API client
testclient = super(TestManagedSystemVMs, cls).getClsTestClient()
cls.apiClient = testclient.getApiClient()
cls.configData = testclient.getParsedTestDataConfig()
cls.dbConnection = testclient.getDbConnection()
cls.testdata = TestData().testdata
cls._connect_to_hypervisor()
# 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 = Zone(get_zone(cls.apiClient, zone_id=cls.testdata[TestData.zoneId]).__dict__)
cls.cluster = list_clusters(cls.apiClient)[0]
cls.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["account"],
admin=1
)
# Set up connection to make customized API calls
cls.user = User.create(
cls.apiClient,
cls.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, cls.user.id)
cls.cs_api = SignedAPICall.CloudStack(api_url, userkeys.apikey, userkeys.secretkey)
cls.compute_offering = ServiceOffering.create(
cls.apiClient,
cls.testdata[TestData.computeOffering]
)
systemoffering = cls.testdata[TestData.systemOffering]
systemoffering[TestData.name] = "Managed SSVM"
systemoffering['systemvmtype'] = "secondarystoragevm"
cls.secondary_storage_offering = ServiceOffering.create(
cls.apiClient,
systemoffering
)
systemoffering[TestData.name] = "Managed CPVM"
systemoffering['systemvmtype'] = "consoleproxy"
cls.console_proxy_offering = ServiceOffering.create(
cls.apiClient,
systemoffering
)
systemoffering[TestData.name] = "Managed VR"
systemoffering['systemvmtype'] = "domainrouter"
cls.virtual_router_offering = ServiceOffering.create(
cls.apiClient,
systemoffering
)
# Resources that are to be destroyed
cls._cleanup = [
cls.secondary_storage_offering,
cls.console_proxy_offering,
cls.virtual_router_offering,
cls.compute_offering,
cls.user,
cls.account
]
@classmethod
def tearDownClass(cls):
try:
cleanup_resources(cls.apiClient, cls._cleanup)
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)
sf_util.purge_solidfire_volumes(self.sfe)
except Exception as e:
logging.debug("Exception in tearDownClass(self): %s" % e)
def test_01_create_system_vms_on_managed_storage(self):
self._disable_zone_and_delete_system_vms(None, False)
primary_storage = self.testdata[TestData.primaryStorage]
primary_storage_1 = StoragePool.create(
self.apiClient,
primary_storage
)
self._prepare_to_use_managed_storage_for_system_vms()
enabled = "Enabled"
self.zone.update(self.apiClient, id=self.zone.id, allocationstate=enabled)
system_vms = self._wait_for_and_get_running_system_vms(2)
virtual_machine = VirtualMachine.create(
self.apiClient,
self.testdata[TestData.virtualMachine],
accountid=self.account.name,
zoneid=self.zone.id,
serviceofferingid=self.compute_offering.id,
templateid=self.template.id,
domainid=self.domain.id,
startvm=True
)
# This virtual machine was only created and started so that the virtual router would be created and started.
# Just delete this virtual machine once it has been created and started.
virtual_machine.delete(self.apiClient, True)
virtual_router = list_routers(self.apiClient, listall=True, state="Running")[0]
system_vms.append(virtual_router)
self._check_system_vms(system_vms, primary_storage_1.id)
primary_storage[TestData.name] = TestData.get_name_for_solidfire_storage()
primary_storage_2 = StoragePool.create(
self.apiClient,
primary_storage
)
StoragePool.enableMaintenance(self.apiClient, primary_storage_1.id)
self._wait_for_storage_cleanup_thread(system_vms)
sf_util.purge_solidfire_volumes(self.sfe)
system_vms = self._wait_for_and_get_running_system_vms(2)
virtual_router = list_routers(self.apiClient, listall=True, state="Running")[0]
system_vms.append(virtual_router)
self._check_system_vms(system_vms, primary_storage_2.id)
StoragePool.cancelMaintenance(self.apiClient, primary_storage_1.id)
primary_storage_1.delete(self.apiClient)
self._disable_zone_and_delete_system_vms(virtual_router)
self._wait_for_storage_cleanup_thread(system_vms)
sf_util.purge_solidfire_volumes(self.sfe)
primary_storage_2.delete(self.apiClient)
self._verify_no_active_solidfire_volumes()
self._prepare_to_stop_using_managed_storage_for_system_vms()
self.zone.update(self.apiClient, id=self.zone.id, allocationstate=enabled)
self._wait_for_and_get_running_system_vms(2)
def test_02_failure_to_create_service_offering_with_customized_iops(self):
try:
ServiceOffering.create(
self.apiClient,
self.testdata[TestData.systemOfferingFailure]
)
except:
return
self.assert_(False, "The service offering was created, but should not have been.")
def _prepare_to_use_managed_storage_for_system_vms(self):
self._update_system_vm_unique_name(TestManagedSystemVMs._secondary_storage_unique_name, TestManagedSystemVMs._secondary_storage_temp_unique_name)
self._update_system_vm_unique_name(TestManagedSystemVMs._console_proxy_unique_name, TestManagedSystemVMs._console_proxy_temp_unique_name)
self._update_system_vm_unique_name(TestManagedSystemVMs._virtual_router_unique_name, TestManagedSystemVMs._virtual_router_temp_unique_name)
self._update_system_vm_unique_name_based_on_uuid(self.secondary_storage_offering.id, TestManagedSystemVMs._secondary_storage_unique_name)
self._update_system_vm_unique_name_based_on_uuid(self.console_proxy_offering.id, TestManagedSystemVMs._console_proxy_unique_name)
self._update_system_vm_unique_name_based_on_uuid(self.virtual_router_offering.id, TestManagedSystemVMs._virtual_router_unique_name)
def _prepare_to_stop_using_managed_storage_for_system_vms(self):
self._update_system_vm_unique_name_based_on_uuid(self.secondary_storage_offering.id, None)
self._update_system_vm_unique_name_based_on_uuid(self.console_proxy_offering.id, None)
self._update_system_vm_unique_name_based_on_uuid(self.virtual_router_offering.id, None)
self._update_system_vm_unique_name(TestManagedSystemVMs._secondary_storage_temp_unique_name, TestManagedSystemVMs._secondary_storage_unique_name)
self._update_system_vm_unique_name(TestManagedSystemVMs._console_proxy_temp_unique_name, TestManagedSystemVMs._console_proxy_unique_name)
self._update_system_vm_unique_name(TestManagedSystemVMs._virtual_router_temp_unique_name, TestManagedSystemVMs._virtual_router_unique_name)
def _wait_for_storage_cleanup_thread(self, system_vms):
retry_interval = 60
num_tries = 10
wait_result, return_val = wait_until(retry_interval, num_tries, self._check_resource_state, system_vms)
if not wait_result:
raise Exception(return_val)
def _check_resource_state(self, system_vms):
try:
self._verify_system_vms_deleted(system_vms)
return True, None
except:
return False, "The system is not in the necessary state."
def _verify_system_vms_deleted(self, system_vms):
for system_vm in system_vms:
cs_root_volume = self._get_root_volume_for_system_vm(system_vm.id, 'Expunged')
self._verify_managed_system_vm_deleted(cs_root_volume.name)
def _disable_zone_and_delete_system_vms(self, virtual_router, verify_managed_system_vm_deleted=True):
self.zone.update(self.apiClient, id=self.zone.id, allocationstate="Disabled")
if virtual_router is not None:
Router.destroy(self.apiClient, virtual_router.id)
if verify_managed_system_vm_deleted:
cs_root_volume = self._get_root_volume_for_system_vm(virtual_router.id, 'Expunged')
self._verify_managed_system_vm_deleted(cs_root_volume.name)
# list_ssvms lists the secondary storage VM and the console proxy VM
system_vms = list_ssvms(self.apiClient)
for system_vm in system_vms:
destroy_ssvm_cmd = destroySystemVm.destroySystemVmCmd()
destroy_ssvm_cmd.id = system_vm.id
self.apiClient.destroySystemVm(destroy_ssvm_cmd)
if verify_managed_system_vm_deleted:
cs_root_volume = self._get_root_volume_for_system_vm(system_vm.id, 'Expunged')
self._verify_managed_system_vm_deleted(cs_root_volume.name)
def _verify_managed_system_vm_deleted(self, cs_root_volume_name):
sf_not_active_volumes = sf_util.get_not_active_sf_volumes(self.sfe)
sf_root_volume = sf_util.check_and_get_sf_volume(sf_not_active_volumes, cs_root_volume_name, self)
self.assertEqual(
len(sf_root_volume.volume_access_groups),
0,
"The volume should not be in a volume access group."
)
if TestData.hypervisor_type == TestData.xenServer:
sr_name = sf_util.format_iqn(sf_root_volume.iqn)
sf_util.check_xen_sr(sr_name, self.xen_session, self, False)
elif TestData.hypervisor_type == TestData.kvm:
list_hosts_response = list_hosts(
self.apiClient,
type="Routing"
)
kvm_login = self.testdata[TestData.kvm]
sf_util.check_kvm_access_to_volume(sf_root_volume.iqn, list_hosts_response, kvm_login[TestData.username], kvm_login[TestData.password], self, False)
else:
self.assertTrue(False, "Invalid hypervisor type")
def _wait_for_and_get_running_system_vms(self, expected_number_of_system_vms):
retry_interval = 60
num_tries = 10
wait_result, return_val = wait_until(retry_interval, num_tries, self._check_number_of_running_system_vms, expected_number_of_system_vms)
if not wait_result:
raise Exception(return_val)
return return_val
def _check_number_of_running_system_vms(self, expected_number_of_system_vms):
# list_ssvms lists the secondary storage VM and the console proxy VM
system_vms = list_ssvms(self.apiClient, state="Running")
if system_vms is not None and len(system_vms) == expected_number_of_system_vms:
return True, system_vms
return False, "Timed out waiting for running system VMs"
def _verify_no_active_solidfire_volumes(self):
sf_active_volumes = sf_util.get_active_sf_volumes(self.sfe)
sf_util.check_list(sf_active_volumes, 0, self, "There should be no active SolidFire volumes in the cluster.")
def _check_system_vms(self, system_vms, primary_storage_id):
sf_active_volumes = sf_util.get_active_sf_volumes(self.sfe)
sf_vag_id = sf_util.get_vag_id(self.cs_api, self.cluster.id, primary_storage_id, self)
for system_vm in system_vms:
cs_root_volume = self._get_root_volume_for_system_vm(system_vm.id, 'Ready')
sf_root_volume = sf_util.check_and_get_sf_volume(sf_active_volumes, cs_root_volume.name, self)
sf_volume_size = sf_util.get_volume_size_with_hsr(self.cs_api, cs_root_volume, self)
sf_util.check_size_and_iops(sf_root_volume, cs_root_volume, sf_volume_size, self)
self._check_iops_against_iops_of_system_offering(cs_root_volume, self.testdata[TestData.systemOffering])
sf_util.check_vag(sf_root_volume, sf_vag_id, self)
if TestData.hypervisor_type == TestData.xenServer:
sr_name = sf_util.format_iqn(sf_root_volume.iqn)
sf_util.check_xen_sr(sr_name, self.xen_session, self)
elif TestData.hypervisor_type == TestData.kvm:
list_hosts_response = list_hosts(
self.apiClient,
type="Routing"
)
kvm_login = self.testdata[TestData.kvm]
sf_util.check_kvm_access_to_volume(sf_root_volume.iqn, list_hosts_response, kvm_login[TestData.username], kvm_login[TestData.password], self)
else:
self.assertTrue(False, "Invalid hypervisor type")
def _check_iops_against_iops_of_system_offering(self, cs_volume, system_offering):
self.assertEqual(
system_offering[TestData.min_iops],
cs_volume.miniops,
"Check QoS - Min IOPS: of " + cs_volume.name + " should be " + str(system_offering[TestData.min_iops])
)
self.assertEqual(
system_offering[TestData.max_iops],
cs_volume.maxiops,
"Check QoS - Min IOPS: of " + cs_volume.name + " should be " + str(system_offering[TestData.max_iops])
)
def _get_root_volume_for_system_vm(self, system_vm_id, state):
sql_query = "Select id From vm_instance Where uuid = '" + system_vm_id + "'"
# make sure you can connect to MySQL: https://teamtreehouse.com/community/cant-connect-remotely-to-mysql-server-with-mysql-workbench
sql_result = self.dbConnection.execute(sql_query)
instance_id = sql_result[0][0]
sql_query = "Select uuid, name, min_iops, max_iops From volumes Where instance_id = " + str(instance_id) + \
" and state = '" + state + "' Order by removed desc"
# make sure you can connect to MySQL: https://teamtreehouse.com/community/cant-connect-remotely-to-mysql-server-with-mysql-workbench
sql_result = self.dbConnection.execute(sql_query)
uuid = sql_result[0][0]
name = sql_result[0][1]
min_iops = sql_result[0][2]
max_iops = sql_result[0][3]
class CloudStackVolume(object):
pass
cs_volume = CloudStackVolume()
cs_volume.id = uuid
cs_volume.name = name
cs_volume.miniops = min_iops
cs_volume.maxiops = max_iops
return cs_volume
def _update_system_vm_unique_name(self, unique_name, new_unique_name):
sql_query = "Update disk_offering set unique_name = '" + new_unique_name + "' Where unique_name = '" + unique_name + "'"
# make sure you can connect to MySQL: https://teamtreehouse.com/community/cant-connect-remotely-to-mysql-server-with-mysql-workbench
self.dbConnection.execute(sql_query)
def _update_system_vm_unique_name_based_on_uuid(self, uuid, new_unique_name):
if (new_unique_name is None):
sql_query = "Update disk_offering set unique_name = NULL Where uuid = '" + uuid + "'"
else:
sql_query = "Update disk_offering set unique_name = '" + new_unique_name + "' Where uuid = '" + uuid + "'"
# make sure you can connect to MySQL: https://teamtreehouse.com/community/cant-connect-remotely-to-mysql-server-with-mysql-workbench
self.dbConnection.execute(sql_query)
@classmethod
def _connect_to_hypervisor(cls):
if TestData.hypervisor_type == TestData.kvm:
pass
elif TestData.hypervisor_type == TestData.xenServer:
host_ip = "https://" + \
list_hosts(cls.apiClient, clusterid=cls.testdata[TestData.clusterId], name=TestData.xen_server_hostname)[0].ipaddress
cls.xen_session = XenAPI.Session(host_ip)
xen_server = cls.testdata[TestData.xenServer]
cls.xen_session.xenapi.login_with_password(xen_server[TestData.username], xen_server[TestData.password])
Reference in New Issue View Git Blame Copy Permalink