| # 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.assertTrue(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]) |