| # 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. |
| """ BVT tests for extensions lifecycle functionalities |
| """ |
| # Import Local Modules |
| from marvin.cloudstackTestCase import cloudstackTestCase |
| from marvin.cloudstackAPI import (listInfrastructure, |
| listManagementServers) |
| from marvin.cloudstackException import CloudstackAPIException |
| from marvin.lib.base import (Extension, |
| Pod, |
| Cluster, |
| Host, |
| Configurations, |
| Template, |
| ServiceOffering, |
| NetworkOffering, |
| Network, |
| VirtualMachine) |
| from marvin.lib.common import (get_zone) |
| from marvin.lib.utils import (random_gen) |
| from marvin.sshClient import SshClient |
| from nose.plugins.attrib import attr |
| # Import System modules |
| import logging |
| from pathlib import Path |
| import random |
| import string |
| import time |
| |
| _multiprocess_shared_ = True |
| |
| CONFIG_EXTENSION_PATH_STATE_CHECK_NAME = "extension.path.state.check.interval" |
| |
| class TestExtensions(cloudstackTestCase): |
| |
| @classmethod |
| def setUpClass(cls): |
| testClient = super(TestExtensions, cls).getClsTestClient() |
| cls.apiclient = testClient.getApiClient() |
| cls.services = testClient.getParsedTestDataConfig() |
| |
| # Get Zone |
| cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests()) |
| |
| cls.mgtSvrDetails = cls.config.__dict__["mgtSvr"][0].__dict__ |
| |
| cls._cleanup = [] |
| cls.logger = logging.getLogger('TestExtensions') |
| cls.logger.setLevel(logging.DEBUG) |
| |
| @classmethod |
| def tearDownClass(cls): |
| super(TestExtensions, cls).tearDownClass() |
| |
| def setUp(self): |
| self.changedConfigurations = {} |
| self.staticConfigurations = [] |
| self.cleanup = [] |
| |
| def tearDown(self): |
| restartServer = False |
| for config in self.changedConfigurations: |
| value = self.changedConfigurations[config] |
| logging.info(f"Reverting value of config: {config} to {value}") |
| Configurations.update(self.apiclient, |
| config, |
| value=value) |
| if config in self.staticConfigurations: |
| restartServer = True |
| if restartServer: |
| self.restartAllManagementServers() |
| super(TestExtensions, self).tearDown() |
| |
| def isManagementUp(self): |
| try: |
| self.apiclient.listInfrastructure(listInfrastructure.listInfrastructureCmd()) |
| return True |
| except Exception: |
| return False |
| |
| def getManagementServerIps(self): |
| if self.mgtSvrDetails["mgtSvrIp"] in ('localhost', '127.0.0.1'): |
| return None |
| cmd = listManagementServers.listManagementServersCmd() |
| servers = self.apiclient.listManagementServers(cmd) |
| active_server_ips = [] |
| active_server_ips.append(self.mgtSvrDetails["mgtSvrIp"]) |
| for idx, server in enumerate(servers): |
| if server.state == 'Up' and server.ipaddress != self.mgtSvrDetails["mgtSvrIp"]: |
| active_server_ips.append(server.ipaddress) |
| return active_server_ips |
| |
| def restartAllManagementServers(self): |
| """Restart all management servers |
| Assumes all servers have same username and password""" |
| server_ips = self.getManagementServerIps() |
| if server_ips is None: |
| self.staticConfigurations.clear() |
| self.fail(f"MS restarts cannot be done on {self.mgtSvrDetails['mgtSvrIp']}") |
| return False |
| logging.info("Restarting all management server") |
| for idx, server_ip in enumerate(server_ips): |
| logging.info(f"Restarting management server #{idx} with IP {server_ip}") |
| sshClient = SshClient( |
| server_ip, |
| 22, |
| self.mgtSvrDetails["user"], |
| self.mgtSvrDetails["passwd"] |
| ) |
| command = "service cloudstack-management stop" |
| sshClient.execute(command) |
| command = "service cloudstack-management start" |
| sshClient.execute(command) |
| if idx == 0: |
| # Wait before restarting other management servers to make the first as oldest running |
| time.sleep(10) |
| |
| # Waits for management to come up in 10 mins, when it's up it will continue |
| timeout = time.time() + (10 * 60) |
| while time.time() < timeout: |
| if self.isManagementUp() is True: return True |
| time.sleep(5) |
| logging.info("Management server did not come up, failing") |
| return False |
| |
| def changeConfiguration(self, name, value): |
| current_config = Configurations.list(self.apiclient, name=name)[0] |
| if current_config.value == str(value): |
| return |
| logging.info(f"Current value for config: {name} is {current_config.value}, changing it to {value}") |
| self.changedConfigurations[name] = current_config.value |
| if current_config.isdynamic == False: |
| self.staticConfigurations.append(name) |
| Configurations.update(self.apiclient, |
| name, |
| value=value) |
| |
| def create_cluster(self): |
| pod_list = Pod.list(self.apiclient) |
| if len(pod_list) <= 0: |
| self.fail("No Pods found") |
| pod_id = pod_list[0].id |
| cluster_services = { |
| 'clustername': 'C0-Test-' + random_gen(), |
| 'clustertype': 'CloudManaged' |
| } |
| self.cluster = Cluster.create( |
| self.apiclient, |
| cluster_services, |
| self.zone.id, |
| pod_id, |
| 'External' |
| ) |
| self.cleanup.append(self.cluster) |
| |
| def move_extension_path_locally(self, source, target): |
| try: |
| Path(source).rename(target) |
| except Exception as e: |
| self.fail(f"Failed to move extension path on localhost: {str(e)}") |
| |
| def move_extension_path(self, path, restore=False): |
| logging.info(f"Moving path {path}") |
| source = path |
| target = f"{path}-backup" |
| if restore: |
| source = target |
| target = path |
| server_ips = self.getManagementServerIps() |
| if server_ips is None: |
| if self.mgtSvrDetails["mgtSvrIp"] in ('localhost', '127.0.0.1'): |
| self.move_extension_path_locally(source, target) |
| return |
| self.fail(f"Extension path cannot be moved on {cls.mgtSvrDetails['mgtSvrIp']}") |
| logging.info(f"Moving {path} on all management servers") |
| command = f"mv {source} {target}" |
| for idx, server_ip in enumerate(server_ips): |
| logging.info(f"Moving {path} on management server #{idx} with IP {server_ip}") |
| sshClient = SshClient( |
| server_ip, |
| 22, |
| self.mgtSvrDetails["user"], |
| self.mgtSvrDetails["passwd"] |
| ) |
| sshClient.execute(command) |
| |
| @attr(tags=["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false") |
| def test_01_create_extension(self): |
| name = random_gen() |
| type = 'Orchestrator' |
| details = [{}] |
| details[0]['abc'] = 'xyz' |
| self.extension = Extension.create( |
| self.apiclient, |
| name=name, |
| type=type, |
| details=details |
| ) |
| self.cleanup.append(self.extension) |
| self.assertEqual( |
| name, |
| self.extension.name, |
| "Check extension name failed" |
| ) |
| self.assertEqual( |
| type, |
| self.extension.type, |
| "Check extension type failed" |
| ) |
| self.assertEqual( |
| 'Enabled', |
| self.extension.state, |
| "Check extension state failed" |
| ) |
| self.assertTrue( |
| self.extension.pathready, |
| "Check extension path ready failed" |
| ) |
| extension_details = self.extension.details.__dict__ |
| for k, v in details[0].items(): |
| self.assertIn(k, extension_details, f"Key '{k}' should be present in details") |
| self.assertEqual(v, extension_details[k], f"Value for key '{k}' should be '{v}'") |
| |
| @attr(tags=["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false") |
| def test_02_create_extension_type_fail(self): |
| type = 'Random' |
| try: |
| self.extension = Extension.create( |
| self.apiclient, |
| name=random_gen(), |
| type=type |
| ) |
| self.cleanup.append(self.extension) |
| self.fail(f"Unknown type: {type} extension created") |
| except CloudstackAPIException: pass |
| |
| @attr(tags=["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false") |
| def test_03_create_extension_name_fail(self): |
| name = random_gen() |
| self.extension = Extension.create( |
| self.apiclient, |
| name=name, |
| type='Orchestrator' |
| ) |
| self.cleanup.append(self.extension) |
| try: |
| self.extension1 = Extension.create( |
| self.apiclient, |
| name=name, |
| type='Orchestrator' |
| ) |
| self.cleanup.append(self.extension1) |
| self.fail(f"Same name: {name} extension created twice") |
| except CloudstackAPIException: pass |
| |
| @attr(tags=["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false") |
| def test_04_update_extension(self): |
| details = [{}] |
| details[0]['abc'] = 'xyz' |
| self.extension = Extension.create( |
| self.apiclient, |
| name=random_gen(), |
| type='Orchestrator', |
| description='Test description', |
| state='Disabled', |
| details=details |
| ) |
| self.cleanup.append(self.extension) |
| |
| details[0]['bca'] = 'yzx' |
| description = 'Updated test description' |
| state = 'Enabled' |
| updated_extension = self.extension.update( |
| self.apiclient, |
| description=description, |
| state=state, |
| details=details) |
| self.assertEqual( |
| description, |
| updated_extension.description, |
| "Check extension description" |
| ) |
| self.assertEqual( |
| state, |
| updated_extension.state, |
| "Check extension state" |
| ) |
| self.assertTrue( |
| updated_extension.details is not None, |
| "Check extension details not None" |
| ) |
| updated_details = updated_extension.details.__dict__ |
| for k, v in details[0].items(): |
| self.assertIn(k, updated_details, f"Key '{k}' should be present in updated details") |
| self.assertEqual(v, updated_details[k], f"Value for key '{k}' should be '{v}'") |
| |
| @attr(tags=["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false") |
| def test_05_register_unregister_extension(self): |
| self.create_cluster() |
| self.extension = Extension.create( |
| self.apiclient, |
| name=random_gen(), |
| type='Orchestrator' |
| ) |
| self.cleanup.append(self.extension) |
| registered_extension = self.extension.register(self.apiclient, self.cluster.id, 'Cluster') |
| resource_found = False |
| if registered_extension is not None and registered_extension.resources is not None and len(registered_extension.resources) > 0: |
| for resource in registered_extension.resources: |
| if resource.id == self.cluster.id and resource.type == 'Cluster': |
| resource_found = True |
| break |
| self.assertTrue(resource_found, "Registered resource not found") |
| self.extension.unregister(self.apiclient, self.cluster.id, 'Cluster') |
| |
| @attr(tags=["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false") |
| def test_06_register_extension_already_fail(self): |
| self.create_cluster() |
| self.extension = Extension.create( |
| self.apiclient, |
| name=random_gen(), |
| type='Orchestrator' |
| ) |
| self.cleanup.append(self.extension) |
| registered_extension = self.extension.register(self.apiclient,self.cluster.id, 'Cluster')['extension'] |
| self.extension1 = Extension.create( |
| self.apiclient, |
| name=random_gen(), |
| type='Orchestrator' |
| ) |
| self.cleanup.append(self.extension1) |
| try: |
| self.extension1.register(self.apiclient, self.cluster.id, 'Cluster') |
| self.fail(f"Same cluster: {cluster.id} registered with two extensions") |
| except CloudstackAPIException: pass |
| |
| @attr(tags=["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false") |
| def test_07_delete_extension_registered_resource_fail(self): |
| self.create_cluster() |
| self.extension = Extension.create( |
| self.apiclient, |
| name=random_gen(), |
| type='Orchestrator' |
| ) |
| self.cleanup.append(self.extension) |
| self.extension.register(self.apiclient, self.cluster.id, 'Cluster') |
| try: |
| self.extension.delete(self.apiclient, False) |
| self.fail("Deleted extensions which is registered to a resource") |
| except CloudstackAPIException: pass |
| |
| @attr(tags=["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false") |
| def test_08_extension_sync(self): |
| sync_task_interval = 60 |
| if self.mgtSvrDetails["mgtSvrIp"] in ('localhost', '127.0.0.1'): |
| sync_config = Configurations.list(self.apiclient, name=CONFIG_EXTENSION_PATH_STATE_CHECK_NAME)[0] |
| if sync_config.value != str(sync_task_interval): |
| self.skipTest("Test running on localhost, MS cannot be restarted to change config") |
| self.extension = Extension.create( |
| self.apiclient, |
| name=random_gen(), |
| type='Orchestrator' |
| ) |
| self.assertTrue(self.extension.pathready, "Path not ready") |
| self.changeConfiguration(CONFIG_EXTENSION_PATH_STATE_CHECK_NAME, sync_task_interval) |
| if len(self.staticConfigurations) > 0: |
| self.restartAllManagementServers() |
| self.move_extension_path(self.extension.path) |
| wait_multiple = 1.5 |
| wait = wait_multiple * sync_task_interval |
| logging.info(f"Waiting for {wait_multiple}x{sync_task_interval} = {wait} seconds for background task to execute") |
| time.sleep(wait) |
| ext = Extension.list( |
| self.apiclient, |
| id=self.extension.id |
| )[0] |
| self.assertFalse(ext.pathready, "Path is still ready") |
| self.move_extension_path(self.extension.path, True) |
| logging.info(f"Waiting for {wait_multiple}x{sync_task_interval} = {wait} seconds for background task to execute") |
| time.sleep(wait) |
| ext = Extension.list( |
| self.apiclient, |
| id=self.extension.id |
| )[0] |
| self.assertTrue(ext.pathready, "Path not ready") |
| |
| @attr(tags=["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false") |
| def test_09_extension_deploy_vm(self): |
| self.create_cluster() |
| self.extension = Extension.create( |
| self.apiclient, |
| name=random_gen(), |
| type='Orchestrator' |
| ) |
| self.cleanup.append(self.extension) |
| self.extension.register(self.apiclient, self.cluster.id, 'Cluster') |
| details = { |
| 'url': random_gen(), |
| 'zoneid': self.cluster.zoneid, |
| 'podid': self.cluster.podid, |
| 'username': 'External', |
| 'password': 'External' |
| } |
| self.host = Host.create( |
| self.apiclient, |
| self.cluster, |
| details, |
| hypervisor=self.cluster.hypervisortype |
| ) |
| self.cleanup.append(self.host) |
| template_name = "ext-" + random_gen() |
| template_data = { |
| "name": template_name, |
| "displaytext": template_name, |
| "format": self.host.hypervisor, |
| "hypervisor": self.host.hypervisor, |
| "ostype": "Other Linux (64-bit)", |
| "url": template_name, |
| "requireshvm": "True", |
| "ispublic": "True", |
| "isextractable": "True", |
| "extensionid": self.extension.id |
| } |
| self.template = Template.register( |
| self.apiclient, |
| template_data, |
| zoneid=self.zone.id, |
| hypervisor=self.cluster.hypervisortype |
| ) |
| self.cleanup.append(self.template) |
| logging.info("Waiting for 3 seconds for template to be ready") |
| time.sleep(3) |
| self.compute_offering = ServiceOffering.create( |
| self.apiclient, |
| self.services["service_offerings"]["tiny"]) |
| self.cleanup.append(self.compute_offering) |
| self.network_offering = NetworkOffering.create( |
| self.apiclient, |
| self.services["l2-network_offering"], |
| ) |
| self.cleanup.append(self.network_offering) |
| self.network_offering.update(self.apiclient, state='Enabled') |
| self.services["network"]["networkoffering"] = self.network_offering.id |
| self.l2_network = Network.create( |
| self.apiclient, |
| self.services["l2-network"], |
| zoneid=self.zone.id, |
| networkofferingid=self.network_offering.id |
| ) |
| self.cleanup.append(self.l2_network) |
| self.services["virtual_machine"]["zoneid"] = self.zone.id |
| self.services["virtual_machine"]["template"] = self.template.id |
| self.virtual_machine = VirtualMachine.create( |
| self.apiclient, |
| self.services["virtual_machine"], |
| templateid=self.template.id, |
| serviceofferingid=self.compute_offering.id, |
| networkids=[self.l2_network.id] |
| ) |
| self.cleanup.append(self.virtual_machine) |
| self.assertEqual( |
| self.virtual_machine.state, |
| 'Running', |
| "VM not in Running state" |
| ) |
