| # 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 |
| |
| # 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, ServiceOffering, Snapshot, StoragePool, User, VirtualMachine, Volume |
| |
| # common - commonly used methods for all tests are listed here |
| from marvin.lib.common import list_clusters, get_domain, list_hosts, list_snapshots, get_template, list_volumes, get_zone |
| |
| # 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 |
| # |
| # Running the tests: |
| # If using XenServer, verify the "xen_server_hostname" variable is correct. |
| # |
| # Note: |
| # If you do have more than one cluster, you might need to change this line: cls.cluster = list_clusters(cls.apiClient)[0] |
| |
| |
| class TestData(): |
| # constants |
| account = "account" |
| capacityBytes = "capacitybytes" |
| capacityIops = "capacityiops" |
| clusterId = "clusterId" |
| computeOffering = "computeoffering" |
| domainId = "domainId" |
| email = "email" |
| firstname = "firstname" |
| hypervisor = "hypervisor" |
| lastname = "lastname" |
| managementServer = "managementServer" |
| mvip = "mvip" |
| name = "name" |
| nfs_folder = "/export/primary2" |
| nfs_path = "nfs://10.117.40.114" + nfs_folder |
| nfs_storage_tag = "NFS-123" |
| password = "password" |
| podId = "podId" |
| port = "port" |
| primaryStorage = "primarystorage" |
| primaryStorage2 = "primarystorage2" |
| provider = "provider" |
| scope = "scope" |
| solidFire = "solidfire" |
| storageTag = "SolidFire_SAN_1" |
| tags = "tags" |
| url = "url" |
| user = "user" |
| username = "username" |
| xenServer = "xenserver" |
| zoneId = "zoneId" |
| |
| 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.xenServer: { |
| TestData.username: "root", |
| TestData.password: "solidfire" |
| }, |
| TestData.managementServer: { |
| TestData.username: "cloudstack", |
| 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: "NFS-%d" % random.randint(0, 100), |
| TestData.scope: "CLUSTER", |
| TestData.clusterId: 1, |
| TestData.url: TestData.nfs_path, |
| TestData.tags: TestData.nfs_storage_tag |
| }, |
| TestData.primaryStorage2: { |
| TestData.name: "SolidFire-%d" % random.randint(0, 100), |
| 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, # 2 PiB |
| TestData.hypervisor: "Any" |
| }, |
| TestData.computeOffering: { |
| TestData.name: "SF_CO_1", |
| "displaytext": "SF_CO_1 (Min IOPS = 300; Max IOPS = 600)", |
| "cpunumber": 1, |
| "cpuspeed": 100, |
| "memory": 128, |
| "storagetype": "shared", |
| "customizediops": False, |
| "miniops": "300", |
| "maxiops": "600", |
| "hypervisorsnapshotreserve": 200, |
| TestData.tags: TestData.nfs_storage_tag |
| }, |
| TestData.zoneId: 1, |
| TestData.podId: 1, |
| TestData.clusterId: 1, |
| TestData.domainId: 1, |
| TestData.url: "10.117.40.114" |
| } |
| |
| |
| class TestOnlineStorageMigration(cloudstackTestCase): |
| _should_only_be_one_volume_in_list_err_msg = "There should only be one volume in this list." |
| _volume_not_on_correct_primary_storage = "The volume is not on the correct primary storage." |
| _snapshot_not_associated_with_correct_volume = "The snapshot is not associated with the correct volume." |
| |
| @classmethod |
| def setUpClass(cls): |
| # Set up API client |
| testclient = super(TestOnlineStorageMigration, cls).getClsTestClient() |
| |
| cls.apiClient = testclient.getApiClient() |
| cls.configData = testclient.getParsedTestDataConfig() |
| cls.dbConnection = testclient.getDbConnection() |
| |
| cls.testdata = TestData().testdata |
| |
| sf_util.set_supports_resign(True, cls.dbConnection) |
| |
| 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 = get_zone(cls.apiClient, zone_id=cls.testdata[TestData.zoneId]) |
| 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) |
| |
| primarystorage = cls.testdata[TestData.primaryStorage] |
| |
| cls.primary_storage = StoragePool.create( |
| cls.apiClient, |
| primarystorage, |
| scope=primarystorage[TestData.scope], |
| zoneid=cls.zone.id, |
| podid=cls.testdata[TestData.podId], |
| clusterid=cls.cluster.id, |
| tags=primarystorage[TestData.tags] |
| ) |
| |
| primarystorage2 = cls.testdata[TestData.primaryStorage2] |
| |
| cls.primary_storage_2 = StoragePool.create( |
| cls.apiClient, |
| primarystorage2, |
| scope=primarystorage2[TestData.scope], |
| zoneid=cls.zone.id, |
| provider=primarystorage2[TestData.provider], |
| tags=primarystorage2[TestData.tags], |
| capacityiops=primarystorage2[TestData.capacityIops], |
| capacitybytes=primarystorage2[TestData.capacityBytes], |
| hypervisor=primarystorage2[TestData.hypervisor] |
| ) |
| |
| cls.compute_offering = ServiceOffering.create( |
| cls.apiClient, |
| cls.testdata[TestData.computeOffering] |
| ) |
| |
| # Resources that are to be destroyed |
| cls._cleanup = [ |
| cls.compute_offering, |
| cls.user, |
| cls.account |
| ] |
| |
| @classmethod |
| def tearDownClass(cls): |
| try: |
| cleanup_resources(cls.apiClient, cls._cleanup) |
| |
| cls.primary_storage.delete(cls.apiClient) |
| cls.primary_storage_2.delete(cls.apiClient) |
| |
| ms = cls.testdata[TestData.managementServer] |
| ip_address = cls.testdata[TestData.url] |
| |
| cls._delete_all_files(ip_address, ms[TestData.username], ms[TestData.password], TestData.nfs_folder) |
| |
| 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): |
| cleanup_resources(self.apiClient, self.cleanup) |
| |
| def test_online_migrate_volume_from_nfs_storage_to_managed_storage(self): |
| if TestData.hypervisor_type != TestData.xenServer: |
| return |
| |
| virtual_machine = VirtualMachine.create( |
| self.apiClient, |
| self._get_vm_name(), |
| accountid=self.account.name, |
| zoneid=self.zone.id, |
| serviceofferingid=self.compute_offering.id, |
| templateid=self.template.id, |
| domainid=self.domain.id, |
| startvm=True |
| ) |
| |
| self.cleanup.append(virtual_machine) |
| |
| vm_root_volume = self._get_only_volume(virtual_machine.id) |
| |
| self._verify_volume_on_primary_storage(vm_root_volume, self.primary_storage) |
| |
| # Migrate the root disk from NFS storage to managed storage. |
| |
| Volume.migrate(self.apiClient, livemigrate=True, volumeid=vm_root_volume.id, storageid=self.primary_storage_2.id) |
| |
| vm_root_volume = self._get_only_volume(virtual_machine.id) |
| |
| self._verify_volume_on_primary_storage(vm_root_volume, self.primary_storage_2) |
| |
| def test_online_migrate_volume_with_snapshot_from_nfs_storage_to_managed_storage(self): |
| if TestData.hypervisor_type != TestData.xenServer: |
| return |
| |
| virtual_machine = VirtualMachine.create( |
| self.apiClient, |
| self._get_vm_name(), |
| accountid=self.account.name, |
| zoneid=self.zone.id, |
| serviceofferingid=self.compute_offering.id, |
| templateid=self.template.id, |
| domainid=self.domain.id, |
| startvm=True |
| ) |
| |
| self.cleanup.append(virtual_machine) |
| |
| vm_root_volume = self._get_only_volume(virtual_machine.id) |
| |
| self._verify_volume_on_primary_storage(vm_root_volume, self.primary_storage) |
| |
| vol_snap = Snapshot.create( |
| self.apiClient, |
| volume_id=vm_root_volume.id |
| ) |
| |
| self.cleanup.append(vol_snap) |
| |
| self._verify_snapshot_belongs_to_volume(vol_snap.id, vm_root_volume.id) |
| |
| # Migrate the root disk from NFS storage to managed storage. |
| |
| Volume.migrate(self.apiClient, livemigrate=True, volumeid=vm_root_volume.id, storageid=self.primary_storage_2.id) |
| |
| vm_root_volume = self._get_only_volume(virtual_machine.id) |
| |
| self._verify_volume_on_primary_storage(vm_root_volume, self.primary_storage_2) |
| |
| self._verify_snapshot_belongs_to_volume(vol_snap.id, vm_root_volume.id) |
| |
| def _verify_snapshot_belongs_to_volume(self, snapshot_id, volume_id): |
| snapshot = list_snapshots( |
| self.apiClient, |
| id=snapshot_id |
| )[0] |
| |
| self.assertEqual( |
| snapshot.volumeid, |
| volume_id, |
| TestOnlineStorageMigration._snapshot_not_associated_with_correct_volume |
| ) |
| |
| def _get_only_volume(self, virtual_machine_id): |
| list_volumes_response = list_volumes( |
| self.apiClient, |
| virtualmachineid=virtual_machine_id, |
| listall=True |
| ) |
| |
| sf_util.check_list(list_volumes_response, 1, self, TestOnlineStorageMigration._should_only_be_one_volume_in_list_err_msg) |
| |
| return list_volumes_response[0] |
| |
| def _verify_volume_on_primary_storage(self, vm_root_volume, primary_storage): |
| self.assertEqual( |
| vm_root_volume.storageid, |
| primary_storage.id, |
| TestOnlineStorageMigration._volume_not_on_correct_primary_storage |
| ) |
| |
| def _get_vm_name(self): |
| number = random.randint(0, 1000) |
| |
| vm_name = { |
| TestData.name: "VM-%d" % number, |
| "displayname": "Test VM %d" % number |
| } |
| |
| return vm_name |
| |
| @classmethod |
| def _delete_all_files(cls, ip_address, username, password, path): |
| ssh_connection = sf_util.get_ssh_connection(ip_address, username, password) |
| |
| ssh_connection.exec_command("sudo rm -rf " + path + "/*") |
| |
| ssh_connection.close() |
| |
| @classmethod |
| def _connect_to_hypervisor(cls): |
| 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]) |
