| # 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") |
