| # 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. | |
| """ | |
| Tests for Shared FileSystem | |
| """ | |
| import time | |
| # Import Local Modules | |
| from nose.plugins.attrib import attr | |
| from marvin.cloudstackAPI import (createFirewallRule, | |
| createPortForwardingRule) | |
| from marvin.cloudstackTestCase import cloudstackTestCase | |
| from marvin.lib.utils import (cleanup_resources, | |
| wait_until) | |
| from marvin.lib.base import (Account, | |
| VirtualMachine, | |
| Network, | |
| SharedFS, | |
| ServiceOffering, | |
| NetworkOffering, | |
| DiskOffering, | |
| PublicIPAddress, | |
| ) | |
| from marvin.lib.common import (get_domain, | |
| get_zone, | |
| get_template, | |
| list_storage_pools) | |
| from marvin.codes import FAILED | |
| from marvin.lib.decoratorGenerators import skipTestIf | |
| class TestSharedFSLifecycle(cloudstackTestCase): | |
| @classmethod | |
| def setUpClass(cls): | |
| cls.testClient = super(TestSharedFSLifecycle, cls).getClsTestClient() | |
| cls.apiclient = cls.testClient.getApiClient() | |
| cls.services = cls.testClient.getParsedTestDataConfig() | |
| cls.domain = get_domain(cls.apiclient) | |
| cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests()) | |
| cls._cleanup = [] | |
| cls.hypervisor = cls.testClient.getHypervisorInfo() | |
| cls.hypervisorNotSupported = False | |
| if cls.hypervisor.lower() not in ["kvm", "vmware"]: | |
| cls.hypervisorNotSupported = True | |
| return | |
| cls.services["service_offering"]["name"] = 'FSVM offering'; | |
| cls.services["service_offering"]["offerha"] = True; | |
| cls.services["service_offering"]["cpunumber"] = 2; | |
| cls.services["service_offering"]["cpuspeed"] = 500; | |
| cls.services["service_offering"]["memory"] = 1024; | |
| cls.service_offering = ServiceOffering.create( | |
| cls.apiclient, | |
| cls.services["service_offering"] | |
| ) | |
| cls._cleanup.append(cls.service_offering) | |
| cls.services["disk_offering"]["disksize"] = 1; | |
| cls.disk_offering = DiskOffering.create( | |
| cls.apiclient, | |
| cls.services["disk_offering"], | |
| custom=True | |
| ) | |
| cls._cleanup.append(cls.disk_offering) | |
| cls.useraccount = Account.create( | |
| cls.apiclient, | |
| cls.services["account"], | |
| domainid=cls.domain.id | |
| ) | |
| cls._cleanup.append(cls.useraccount) | |
| cls.adminaccount = Account.create( | |
| cls.apiclient, | |
| cls.services["account"], | |
| domainid=cls.domain.id, | |
| admin=True | |
| ) | |
| cls._cleanup.append(cls.adminaccount) | |
| cls.network_offering_isolated = NetworkOffering.create( | |
| cls.apiclient, | |
| cls.services["isolated_network_offering"] | |
| ) | |
| cls.network_offering_isolated.update(cls.apiclient, state='Enabled') | |
| cls._cleanup.append(cls.network_offering_isolated) | |
| cls.services["network"]["name"] = "Test Network Isolated" | |
| cls.user_network = Network.create( | |
| cls.apiclient, | |
| cls.services["network"], | |
| networkofferingid=cls.network_offering_isolated.id, | |
| domainid=cls.domain.id, | |
| accountid=cls.adminaccount.name, | |
| zoneid=cls.zone.id | |
| ) | |
| cls._cleanup.insert(0, cls.user_network) | |
| cls.public_ipaddress = None | |
| cls.sshpublicport = 1000 | |
| cls.template = get_template( | |
| cls.apiclient, | |
| cls.zone.id, | |
| cls.services["ostype"]) | |
| if cls.template == FAILED: | |
| assert False, "get_template() failed to return template with description %s" % cls.services["ostype"] | |
| cls.services["domainid"] = cls.domain.id | |
| cls.services["zoneid"] = cls.zone.id | |
| cls.services["diskofferingid"] = cls.disk_offering.id | |
| cls.services["serviceofferingid"] = cls.service_offering.id | |
| cls.services["networkid"] = cls.user_network.id | |
| cls.services["account"] = cls.adminaccount.name | |
| cls.sharedfs = SharedFS.create( | |
| cls.apiclient, | |
| cls.services, | |
| name='Test Shared FileSystem 1', | |
| size=2, | |
| filesystem='XFS' | |
| ) | |
| cls._cleanup.insert(0, cls.sharedfs) | |
| cls.virtual_machine1 = VirtualMachine.create( | |
| cls.apiclient, | |
| cls.services["virtual_machine"], | |
| templateid=cls.template.id, | |
| serviceofferingid=cls.service_offering.id, | |
| networkids=cls.user_network.id, | |
| domainid=cls.domain.id, | |
| accountid=cls.adminaccount.name, | |
| zoneid=cls.zone.id | |
| ) | |
| cls._cleanup.insert(0, cls.virtual_machine1) | |
| cls.public_ipaddress = cls.setUpSNAT(cls, cls.user_network) | |
| cls.debug("Public ipaddress: " + cls.public_ipaddress.ipaddress) | |
| port = cls.setUpPortForwarding(cls, cls.virtual_machine1.id) | |
| cls.vm1_ssh_client = cls.getSSHClient(cls, cls.virtual_machine1, port) | |
| @classmethod | |
| def tearDownClass(cls): | |
| try: | |
| cleanup_resources(cls.apiclient, cls._cleanup) | |
| except Exception as e: | |
| raise Exception("Warning: Exception during cleanup : %s" % e) | |
| def setUp(self): | |
| self.apiclient = self.testClient.getApiClient() | |
| self.dbclient = self.testClient.getDbConnection() | |
| self.cleanup = [] | |
| return | |
| def tearDown(self): | |
| try: | |
| self.debug("Cleaning up the resources") | |
| cleanup_resources(self.apiclient, self.cleanup) | |
| self.debug("Cleanup complete!") | |
| except Exception as e: | |
| self.debug("Warning! Exception in tearDown: %s" % e) | |
| def setUpSNAT(self, network): | |
| public_ipaddress = PublicIPAddress.list( | |
| self.apiclient, | |
| account=self.adminaccount.name, | |
| domainid=self.domain.id, | |
| associatednetworkid=network.id | |
| ) | |
| createFwRule = createFirewallRule.createFirewallRuleCmd() | |
| createFwRule.cidrlist = "0.0.0.0/0" | |
| createFwRule.startport = 22 | |
| createFwRule.endport = 22 | |
| createFwRule.ipaddressid = public_ipaddress[0].id | |
| createFwRule.protocol = "tcp" | |
| self.apiclient.createFirewallRule(createFwRule) | |
| return public_ipaddress[0] | |
| def setUpPortForwarding(self, virtualmachineid): | |
| createPfRule = createPortForwardingRule.createPortForwardingRuleCmd() | |
| self.sshpublicport += 1 | |
| createPfRule.publicport = self.sshpublicport | |
| createPfRule.privateport = 22 | |
| createPfRule.virtualmachineid = virtualmachineid | |
| createPfRule.ipaddressid = self.public_ipaddress.id | |
| createPfRule.protocol = "tcp" | |
| self.apiclient.createPortForwardingRule(createPfRule) | |
| self.debug("Successfully programmed PF rule for :%s"%self.public_ipaddress.ipaddress) | |
| return createPfRule.publicport | |
| def getSSHClient(self, virtual_machine, port): | |
| try: | |
| ssh_client = virtual_machine.get_ssh_client(ipaddress=self.public_ipaddress.ipaddress, port=port) | |
| except Exception as e: | |
| self.fail("SSH failed for virtual machine: %s - %s" % (virtual_machine.ipaddress, e)) | |
| return ssh_client | |
| def mountSharedFSOnVM(self, ssh_client, sharedfs): | |
| sharedfs_ip = sharedfs.nic[0].ipaddress | |
| ssh_client.execute("mkdir /mnt/fs1") | |
| cmd = "mount -t nfs -o nolock " + sharedfs_ip + ":/export /mnt/fs1" | |
| ssh_client.execute(cmd) | |
| @attr( tags=[ "advanced", "advancedns", "smokes"], required_hardware="true") | |
| @skipTestIf("hypervisorNotSupported") | |
| def test_mount_shared_fs(self): | |
| """Mount Shared FileSystem on two VMs and match contents | |
| """ | |
| self.mountSharedFSOnVM(self.vm1_ssh_client, self.sharedfs) | |
| self.vm1_ssh_client.execute("df -Th /mnt/fs1") | |
| self.vm1_ssh_client.execute("touch /mnt/fs1/test") | |
| try: | |
| self.virtual_machine2 = VirtualMachine.create( | |
| self.apiclient, | |
| self.services["virtual_machine"], | |
| templateid=self.template.id, | |
| serviceofferingid=self.service_offering.id, | |
| networkids=self.user_network.id, | |
| domainid=self.domain.id, | |
| accountid=self.adminaccount.name, | |
| zoneid=self.zone.id | |
| ) | |
| except Exception as e: | |
| self.vm1_ssh_client.execute("rm /mnt/fs1/test") | |
| self.fail(e) | |
| self.cleanup.append(self.virtual_machine2) | |
| port = self.setUpPortForwarding(self.virtual_machine2.id) | |
| ssh_client = self.getSSHClient(self.virtual_machine2, port) | |
| self.assertIsNotNone(ssh_client) | |
| self.mountSharedFSOnVM(ssh_client, self.sharedfs) | |
| ssh_client.execute("df -Th /mnt/fs1") | |
| result = ssh_client.execute("ls /mnt/fs1/test") | |
| self.assertEqual(result[0], "/mnt/fs1/test") | |
| @attr( tags=[ "advanced", "advancedns", "smokes"], required_hardware="true") | |
| @skipTestIf("hypervisorNotSupported") | |
| def test_resize_shared_fs(self): | |
| """Resize the shared filesystem by changing the disk offering and validate | |
| """ | |
| sharedfs_pool_response = list_storage_pools(self.apiclient, id=self.sharedfs.storageid) | |
| sharedfs_pool = sharedfs_pool_response[0] | |
| self.mountSharedFSOnVM(self.vm1_ssh_client, self.sharedfs) | |
| result = self.vm1_ssh_client.execute("df -Th /mnt/fs1 | grep nfs")[0] | |
| self.debug(result) | |
| size = result.split()[-5] | |
| self.debug("Size of the filesystem is " + size) | |
| if sharedfs_pool.type.lower() == "powerflex": | |
| self.assertEqual(size, "8.0G", "SharedFS size should be 8.0G") | |
| new_size = 9 | |
| else: | |
| self.assertEqual(size, "2.0G", "SharedFS size should be 2.0G") | |
| new_size = 3 | |
| response = SharedFS.stop(self.sharedfs, self.apiclient) | |
| response = SharedFS.changediskoffering(self.sharedfs, self.apiclient, self.disk_offering.id, new_size) | |
| self.debug(response) | |
| response = SharedFS.start(self.sharedfs, self.apiclient) | |
| time.sleep(10) | |
| result = self.vm1_ssh_client.execute("df -Th /mnt/fs1 | grep nfs")[0] | |
| size = result.split()[-5] | |
| self.debug("Size of the filesystem is " + size) | |
| if sharedfs_pool.type.lower() == "powerflex": | |
| self.assertEqual(size, "16G", "SharedFS size should be 16G") | |
| else: | |
| self.assertEqual(size, "3.0G", "SharedFS size should be 3.0G") |