nfs-ganesha-Added tests to verify multi volume exports when

IO is in progress and subdir mounts from client and server side

Change-Id: I80b22e6602bbc18652135211ea08710392c04cb6
Signed-off-by: Arthy Loganathan <aloganat@redhat.com>

1 files changed, 355 insertions, 4 deletions

diff --git a/tests/functional/nfs_ganesha/exports/test_nfs_ganesha_volume_exports.py b/tests/functional/nfs_ganesha/exports/test_nfs_ganesha_volume_exports.py
index ba9b47575..0594d2118 100644
--- a/tests/functional/nfs_ganesha/exports/test_nfs_ganesha_volume_exports.py
+++ b/tests/functional/nfs_ganesha/exports/test_nfs_ganesha_volume_exports.py
@@ -30,13 +30,20 @@ from glustolibs.gluster.nfs_ganesha_ops import (enable_acl, disable_acl,
                                                 run_refresh_config,
                                                 enable_nfs_ganesha,
                                                 disable_nfs_ganesha,
-                                                export_nfs_ganesha_volume)
-from glustolibs.gluster.volume_ops import volume_stop, volume_start
-from glustolibs.gluster.volume_libs import get_volume_options
+                                                export_nfs_ganesha_volume,
+                                                unexport_nfs_ganesha_volume)
+from glustolibs.gluster.volume_ops import (volume_stop, volume_start,
+                                           get_volume_info)
+from glustolibs.gluster.volume_libs import (get_volume_options, setup_volume,
+                                            cleanup_volume, is_volume_exported,
+                                            log_volume_info_and_status)
 import time
 from glustolibs.io.utils import (validate_io_procs,
-                                 list_all_files_and_dirs_mounts)
+                                 list_all_files_and_dirs_mounts,
+                                 wait_for_io_to_complete)
 from glustolibs.gluster.exceptions import ExecutionError
+import os
+import re
 
 
 @runs_on([['replicated', 'distributed', 'distributed-replicated',
@@ -210,3 +217,347 @@ class TestNfsGaneshaVolumeExportsWithIO(NfsGaneshaIOBaseClass):
          tearDownClass.
          im_func(cls,
                  teardown_nfsganesha_cluster=False))
+
+
+@runs_on([['replicated', 'distributed', 'distributed-replicated',
+           'dispersed', 'distributed-dispersed'],
+          ['nfs']])
+class TestNfsGaneshaMultiVolumeExportsWithIO(NfsGaneshaIOBaseClass):
+    """
+    Tests to verfiy multiple volumes gets exported when IO is in progress.
+    """
+
+    def test_nfs_ganesha_export_with_multiple_volumes(self):
+        """
+        Testcase to verfiy multiple volumes gets exported when IO is in
+        progress.
+        """
+
+        for i in range(5):
+            self.volume['name'] = "nfsvol" + str(i)
+            self.volume['voltype']['type'] = 'distributed'
+            self.volume['voltype']['replica_count'] = 1
+            self.volume['voltype']['dist_count'] = 2
+
+            # Create volume
+            ret = setup_volume(mnode=self.mnode,
+                               all_servers_info=self.all_servers_info,
+                               volume_config=self.volume, force=True)
+            if not ret:
+                self.assertTrue(ret, ("Setup volume %s failed" % self.volume))
+            time.sleep(5)
+
+            # Export volume with nfs ganesha, if it is not exported already
+            vol_option = get_volume_options(self.mnode, self.volume['name'],
+                                            option='ganesha.enable')
+            if vol_option is None:
+                self.assertTrue(False, ("Failed to get ganesha.enable volume"
+                                        " option for %s "
+                                        % self.volume['name']))
+            if vol_option['ganesha.enable'] != 'on':
+                ret, out, err = export_nfs_ganesha_volume(
+                    mnode=self.mnode, volname=self.volume['name'])
+                if ret != 0:
+                    self.assertTrue(False, ("Failed to export volume %s "
+                                            "as NFS export"
+                                            % self.volume['name']))
+                time.sleep(5)
+            else:
+                g.log.info("Volume %s is exported already"
+                           % self.volume['name'])
+
+            # Waiting for few seconds for volume export. Max wait time is
+            # 120 seconds.
+            ret = wait_for_nfs_ganesha_volume_to_get_exported(self.mnode,
+                                                              (self.
+                                                               volume['name']))
+            self.assertTrue(ret, ("Failed to export volume %s after "
+                                  "starting volume when IO is running on "
+                                  "another volume" % self.volume['name']))
+
+            # Log Volume Info and Status
+            ret = log_volume_info_and_status(self.mnode, self.volume['name'])
+            if not ret:
+                self.assertTrue(False, ("Logging volume %s info and status ",
+                                        "failed " % self.volume['name']))
+
+        # Validate IO
+        g.log.info("Wait for IO to complete and validate IO ...")
+        ret = validate_io_procs(self.all_mounts_procs, self.mounts)
+        self.io_validation_complete = True
+        self.assertTrue(ret, "IO failed on some of the clients")
+        g.log.info("IO is successful on all mounts")
+
+        # List all files and dirs created
+        g.log.info("List all files and directories:")
+        ret = list_all_files_and_dirs_mounts(self.mounts)
+        self.assertTrue(ret, "Failed to list all files and dirs")
+        g.log.info("Listing all files and directories is successful")
+
+    def tearDown(self):
+
+        # Clean up the volumes created specific for this tests.
+        for i in range(5):
+            volname = "nfsvol" + str(i)
+            volinfo = get_volume_info(self.mnode, volname)
+            if volinfo is None or volname not in volinfo:
+                g.log.info("Volume %s does not exist in %s"
+                           % (volname, self.mnode))
+                continue
+
+            # Unexport volume, if it is not unexported already
+            vol_option = get_volume_options(self.mnode, volname,
+                                            option='ganesha.enable')
+            if vol_option is None:
+                raise ExecutionError("Failed to get ganesha.enable volume "
+                                     " option for %s " % volname)
+            if vol_option['ganesha.enable'] != 'off':
+                if is_volume_exported(self.mnode, volname, "nfs"):
+                    ret, out, err = unexport_nfs_ganesha_volume(
+                        mnode=self.mnode, volname=volname)
+                    if ret != 0:
+                        raise ExecutionError("Failed to unexport volume %s "
+                                             % volname)
+                    time.sleep(5)
+            else:
+                g.log.info("Volume %s is unexported already"
+                           % volname)
+
+            _, _, _ = g.run(self.mnode, "showmount -e")
+
+            ret = cleanup_volume(mnode=self.mnode, volname=volname)
+            if not ret:
+                raise ExecutionError("cleanup volume %s failed" % volname)
+
+        NfsGaneshaIOBaseClass.tearDown.im_func(self)
+
+    @classmethod
+    def tearDownClass(cls):
+
+        (NfsGaneshaIOBaseClass.
+         tearDownClass.
+         im_func(cls,
+                 teardown_nfsganesha_cluster=False))
+
+
+@runs_on([['replicated', 'distributed', 'distributed-replicated',
+           'dispersed', 'distributed-dispersed'],
+          ['nfs']])
+class TestNfsGaneshaSubDirExportsWithIO(NfsGaneshaIOBaseClass):
+    """
+    Tests to verfiy nfs ganesha sub directory exports.
+    """
+
+    def start_and_wait_for_io_to_complete(self):
+        """This module starts IO from clients and waits for io to complate.
+        Returns True, if io gets completed successfully. Otherwise, False
+        """
+
+        # Start IO on mounts
+        g.log.info("Starting IO on all mounts...")
+        self.all_mounts_procs = []
+        for mount_obj in self.mounts:
+            cmd = ("python %s create_deep_dirs_with_files "
+                   "--dirname-start-num %d "
+                   "--dir-depth 2 "
+                   "--dir-length 15 "
+                   "--max-num-of-dirs 5 "
+                   "--num-of-files 10 %s" % (self.script_upload_path,
+                                             self.counter,
+                                             mount_obj.mountpoint))
+            proc = g.run_async(mount_obj.client_system, cmd,
+                               user=mount_obj.user)
+            self.all_mounts_procs.append(proc)
+            self.counter = self.counter + 10
+        self.io_validation_complete = False
+
+        # Adding a delay of 15 seconds before test method starts. This
+        # is to ensure IO's are in progress and giving some time to fill data
+        time.sleep(15)
+
+        # Validate IO
+        g.log.info("Wait for IO to complete and validate IO ...")
+        ret = validate_io_procs(self.all_mounts_procs, self.mounts)
+        self.io_validation_complete = True
+        if not ret:
+            g.log.error("IO failed on some of the clients")
+            return False
+        g.log.info("IO is successful on all mounts")
+
+        # List all files and dirs created
+        g.log.info("List all files and directories:")
+        ret = list_all_files_and_dirs_mounts(self.mounts)
+        if not ret:
+            g.log.error("Failed to list all files and dirs")
+            return False
+        g.log.info("Listing all files and directories is successful")
+        return True
+
+    def setUp(self):
+        """setUp writes data from all mounts and selects subdirectory
+           required for the test and unmount the existing mounts.
+        """
+
+        NfsGaneshaIOBaseClass.setUp.im_func(self)
+
+        # Validate IO
+        g.log.info("Wait for IO to complete and validate IO ...")
+        ret = validate_io_procs(self.all_mounts_procs, self.mounts)
+        self.io_validation_complete = True
+        if not ret:
+            raise ExecutionError("IO failed on some of the clients")
+        g.log.info("IO is successful on all mounts")
+
+        # List all files and dirs created
+        g.log.info("List all files and directories:")
+        ret = list_all_files_and_dirs_mounts(self.mounts)
+        if not ret:
+            raise ExecutionError("Failed to list all files and dirs")
+        g.log.info("Listing all files and directories is successful")
+
+        mountpoint = self.mounts[0].mountpoint
+        client = self.mounts[0].client_system
+
+        # Select the subdirectory required for the test.
+        cmd = "find %s -type d -links 2 | grep -ve '.trashcan'" % mountpoint
+        ret, out, err = g.run(client, cmd)
+        if ret != 0:
+            raise ExecutionError("Failed to list the deep level directories")
+        self.subdir_path = out.split("\n")[0]
+
+        _rc = True
+        for mount_obj in self.mounts:
+            ret = mount_obj.unmount()
+            if not ret:
+                g.log.error("Unable to unmount volume '%s:%s' on '%s:%s'",
+                            mount_obj.server_system, mount_obj.volname,
+                            mount_obj.client_system, mount_obj.mountpoint)
+                _rc = False
+        if not _rc:
+            raise ExecutionError("Unmount of all mounts are not "
+                                 "successful")
+
+    def test_nfs_ganesha_subdirectory_mount_from_client_side(self):
+        """
+        Tests script to verify nfs ganesha subdirectory mount from client side
+        succeeds and able to write IOs.
+        """
+
+        for mount_obj in self.mounts:
+            subdir_to_mount = self.subdir_path.replace(mount_obj.mountpoint,
+                                                       '')
+            if not subdir_to_mount.startswith(os.path.sep):
+                subdir_to_mount = os.path.sep + subdir_to_mount
+
+            mount_obj.volname = mount_obj.volname + subdir_to_mount
+            if not mount_obj.is_mounted():
+                ret = mount_obj.mount()
+                self.assertTrue(ret, ("Unable to mount volume '%s:%s' "
+                                      "on '%s:%s'"
+                                      % (mount_obj.server_system,
+                                         mount_obj.volname,
+                                         mount_obj.client_system,
+                                         mount_obj.mountpoint)))
+
+        ret = self.start_and_wait_for_io_to_complete()
+        self.assertTrue(ret, ("Failed to write IOs when sub directory is"
+                              " mounted from client side"))
+
+    def test_nfs_ganesha_subdirectory_mount_from_server_side(self):
+        """
+        Tests script to verify nfs ganesha subdirectory mount from server
+        side succeeds and able to write IOs.
+        """
+        subdir_to_mount = self.subdir_path.replace(self.mounts[0].mountpoint,
+                                                   '')
+        if not subdir_to_mount.startswith(os.path.sep):
+            subdir_to_mount = os.path.sep + subdir_to_mount
+
+        for mount_obj in self.mounts:
+            mount_obj.volname = mount_obj.volname + subdir_to_mount
+
+        export_file = ("/var/run/gluster/shared_storage/nfs-ganesha/exports/"
+                       "export.%s.conf" % self.volname)
+        cmd = ("sed -i  s/'Path = .*'/'Path = \"\/%s\";'/g %s"
+               % (re.escape(self.mounts[0].volname), export_file))
+        ret, _, _ = g.run(self.mnode, cmd)
+        self.assertEqual(ret, 0, ("Unable to change Path info to %s in %s"
+                                  % ("/" + self.mounts[0].volname,
+                                     export_file)))
+
+        cmd = ("sed -i  's/volume=.*/& \\n volpath=\"%s\";/g' %s"
+               % (re.escape(subdir_to_mount), export_file))
+        ret, _, _ = g.run(self.mnode, cmd)
+        self.assertEqual(ret, 0, ("Unable to add volpath info to %s in %s"
+                                  % ("/" + self.mounts[0].volname,
+                                     export_file)))
+
+        cmd = ("sed -i  s/'Pseudo=.*'/'Pseudo=\"\/%s\";'/g %s"
+               % (re.escape(self.mounts[0].volname), export_file))
+        ret, _, _ = g.run(self.mnode, cmd)
+        self.assertEqual(ret, 0, ("Unable to change pseudo Path info to "
+                                  "%s in %s" % ("/" + self.mounts[0].volname,
+                                                export_file)))
+
+        # Stop and start volume to take the modified export file to effect.
+        # Stoping volume
+        ret = volume_stop(self.mnode, self.volname)
+        self.assertTrue(ret, ("Failed to stop volume %s" % self.volname))
+
+        # Waiting for few seconds for volume unexport. Max wait time is
+        # 120 seconds.
+        ret = wait_for_nfs_ganesha_volume_to_get_unexported(self.mnode,
+                                                            self.volname)
+        self.assertTrue(ret, ("Failed to unexport volume %s after "
+                              "stopping volume" % self.volname))
+
+        # Starting volume
+        ret = volume_start(self.mnode, self.volname)
+        self.assertTrue(ret, ("Failed to start volume %s" % self.volname))
+
+        # Waiting for few seconds for volume export. Max wait time is
+        # 120 seconds.
+        ret = wait_for_nfs_ganesha_volume_to_get_exported(self.mnode,
+                                                          (self.mounts[0].
+                                                           volname))
+        self.assertTrue(ret, ("Failed to export sub directory %s after "
+                              "starting volume" % self.mounts[0].volname))
+
+        for mount_obj in self.mounts:
+            if not mount_obj.is_mounted():
+                ret = mount_obj.mount()
+                self.assertTrue(ret, ("Unable to mount volume '%s:%s' "
+                                      "on '%s:%s'"
+                                      % (mount_obj.server_system,
+                                         mount_obj.volname,
+                                         mount_obj.client_system,
+                                         mount_obj.mountpoint)))
+
+        ret = self.start_and_wait_for_io_to_complete()
+        self.assertTrue(ret, ("Failed to write IOs when sub directory is"
+                              " mounted from server side"))
+
+    def tearDown(self):
+        """setUp starts the io from all the mounts.
+            IO creates deep dirs and files.
+        """
+
+        # Wait for IO to complete if io validation is not executed in the
+        # test method
+        if not self.io_validation_complete:
+            g.log.info("Wait for IO to complete as IO validation did not "
+                       "succeed in test method")
+            ret = wait_for_io_to_complete(self.all_mounts_procs, self.mounts)
+            if not ret:
+                raise ExecutionError("IO failed on some of the clients")
+            g.log.info("IO is successful on all mounts")
+
+        NfsGaneshaIOBaseClass.tearDown.im_func(self)
+
+    @classmethod
+    def tearDownClass(cls):
+
+        (NfsGaneshaIOBaseClass.
+         tearDownClass.
+         im_func(cls,
+                 teardown_nfsganesha_cluster=False))