From 27479f8947b0882ce7a2e22d8a12addd96c81276 Mon Sep 17 00:00:00 2001 From: Vinayak Papnoi Date: Thu, 22 Aug 2019 22:16:58 +0530 Subject: [testfix] Use library methods in test_256_snaps The test case 'test_256_snapshots.py' contains hard-coded commands which can be run using the existing library functions from the snap_ops.py library, such as: * snap_create * set_snap_config This patch includes usage of appropriate functions in place of the hard-coded commands along with various cosmetic changes. Change-Id: I6da7444d903efd1be6582c8fea037a5c4fddc111 Signed-off-by: Vinayak Papnoi --- tests/functional/snapshot/test_256_snapshots.py | 210 ++++++++++++------------ 1 file changed, 101 insertions(+), 109 deletions(-) diff --git a/tests/functional/snapshot/test_256_snapshots.py b/tests/functional/snapshot/test_256_snapshots.py index 72528022d..75df2ed4f 100644 --- a/tests/functional/snapshot/test_256_snapshots.py +++ b/tests/functional/snapshot/test_256_snapshots.py @@ -1,4 +1,4 @@ -# Copyright (C) 2016-2017 Red Hat, Inc. +# Copyright (C) 2016-2020 Red Hat, Inc. # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by @@ -14,39 +14,25 @@ # with this program; if not, write to the Free Software Foundation, Inc., # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. -""" -Description : The purpose of this test is to validate create snap>256 -""" - import sys - +from time import sleep from glusto.core import Glusto as g - from glustolibs.gluster.exceptions import ExecutionError from glustolibs.gluster.gluster_base_class import GlusterBaseClass, runs_on from glustolibs.misc.misc_libs import upload_scripts -from glustolibs.io.utils import validate_io_procs, get_mounts_stat -from glustolibs.gluster.snap_ops import get_snap_list, snap_delete_all +from glustolibs.io.utils import ( + wait_for_io_to_complete, + get_mounts_stat) +from glustolibs.gluster.snap_ops import ( + snap_create, + set_snap_config, + get_snap_list, + snap_delete_all) @runs_on([['distributed', 'replicated', 'distributed-replicated', 'dispersed', 'distributed-dispersed'], ['glusterfs', 'nfs', 'cifs']]) -class SanpCreate256(GlusterBaseClass): - """ - Test for snapshot create for max 256 - Steps : - 1. Create and start a volume - 2. Mount the volume on a client - 3. Perform some heavy IO - 4. Varify IO - 5. modify max snap limit to default to 256. - 6. Create 256 snapshots - 7. Varify 256 created successfully - 8. Create 257th snapshot - check for failure - -- it should fail. - 9. Cleanup - - """ +class TestValidateSnaps256(GlusterBaseClass): @classmethod def setUpClass(cls): cls.get_super_method(cls, 'setUpClass')() @@ -67,108 +53,114 @@ class SanpCreate256(GlusterBaseClass): """ setUp method """ - # Setup_Volume self.get_super_method(self, 'setUp')() - ret = self.setup_volume_and_mount_volume(mounts=self.mounts, - volume_create_force=True) + + # Setup_Volume + ret = self.setup_volume_and_mount_volume(mounts=self.mounts) if not ret: raise ExecutionError("Failed to setup and mount volume") g.log.info("Volume %s has been setup successfully", self.volname) + self.all_mounts_procs = [] + self.snapshots = [('snap-test-validate-256-snapshots-%s-%s' + % (self.volname, i))for i in range(0, 256)] + def tearDown(self): """ tearDown """ - ret, _, _ = snap_delete_all(self.mnode) - if not ret: - raise ExecutionError("Failed to delete all snaps") self.get_super_method(self, 'tearDown')() - @classmethod - def tearDownClass(cls): - """ - Clean up the volume & mount - """ - g.log.info("Starting volume and mount cleanup") - ret = cls.unmount_volume_and_cleanup_volume(cls.mounts) + # Delete all snapshots + ret, _, _ = snap_delete_all(self.mnode) + if ret: + raise ExecutionError("Failed to delete all snapshots") + g.log.info("Successfully deleted all snapshots") + + # Unmount and cleanup volume + ret = self.unmount_volume_and_cleanup_volume(mounts=self.mounts) if not ret: raise ExecutionError("Failed to cleanup volume and mount") g.log.info("Cleanup successful for the volume and mount") - cls.get_super_method(cls, 'tearDownClass')() - def test_validate_snaps_256(self): + """ + Validate snapshot creation for 256 snapshots - # Start IO on all mounts. - all_mounts_procs = [] - count = 1 - for mount_obj in self.mounts: - g.log.info("Starting IO on %s:%s", mount_obj.client_system, - mount_obj.mountpoint) - cmd = ("/usr/bin/env python%d %s create_deep_dirs_with_files " - "--dirname-start-num %d " - "--dir-depth 2 " - "--dir-length 10 " - "--max-num-of-dirs 5 " - "--num-of-files 5 %s" % ( - sys.version_info.major, self.script_upload_path, count, - mount_obj.mountpoint)) - proc = g.run_async(mount_obj.client_system, cmd, - user=mount_obj.user) - all_mounts_procs.append(proc) - count = count + 10 - - # Validate IO - g.log.info("Validating IO's") - ret = validate_io_procs(all_mounts_procs, self.mounts) - self.assertTrue(ret, "IO failed on some of the clients") - g.log.info("Successfully validated all io's") - - # Get stat of all the files/dirs created. - g.log.info("Get stat of all the files/dirs created.") + * Perform some IO + * Set snapshot config option snap-max-hard-limit to 256 + * Create 256 snapshots + * Verify 256 created successfully + * Create 257th snapshot - creation should fail as it will + exceed the hard-limit + * Verify snapshot list for 256 snapshots + + """ + # pylint: disable=too-many-statements + # Start IO on all mounts + cmd = ( + "/usr/bin/env python%d %s create_files " + "-f 10 --base-file-name firstfiles %s" + % (sys.version_info.major, + self.script_upload_path, + self.mounts[0].mountpoint)) + proc = g.run_async( + self.mounts[0].client_system, cmd, user=self.mounts[0].user) + self.all_mounts_procs.append(proc) + + # Wait for IO to complete + self.assertTrue( + wait_for_io_to_complete(self.all_mounts_procs, self.mounts[0]), + "IO failed on %s" % self.mounts[0]) + g.log.info("IO is successful on all mounts") + + # Perform stat on all the files/dirs created ret = get_mounts_stat(self.mounts) self.assertTrue(ret, "Stat failed on some of the clients") - g.log.info("Successfully got stat of all files/dirs created") - - # set config for 256 snpas (to make sure to override) - cmd_str = ("gluster snapshot config snap-max-hard-limit 256" - " --mode=script") - ret = g.run(self.mnode, cmd_str) - self.assertTrue(ret, "Failed to set snap-max-hard-limit to 256.") - g.log.info("snap-max-hard limit successfully set for 256.") - - # Create 256 snaps - for i in range(1, 257, 1): - cmd_str = "gluster snapshot create %s %s %s" % ( - "snapy%s" % i, self.volname, "no-timestamp") - ret = g.run(self.mnode, cmd_str) - self.assertTrue(ret, ("Failed to create snapshot for %s" - % self.volname)) - g.log.info("Snapshot %s created successfully for volume %s", - "snapy%s" % i, self.volname) - - # Check for no. of snaps using snap_list it should be 256 + g.log.info("Successfully performed stat on all files/dirs created") + + # Set config option snap-max-hard-limit to 256 + # This is to make sure to override + max_hard_limit = {'snap-max-hard-limit': '256'} + ret, _, _ = set_snap_config(self.mnode, max_hard_limit) + self.assertEqual(ret, 0, "Failed to set snapshot config option " + "snap-max-hard-limit to 256") + g.log.info("Successfully set snapshot config option " + "snap-max-hard-limit to 256") + + # Create 256 snapshots + for snapname in self.snapshots: + ret, _, _ = snap_create(self.mnode, self.volname, snapname) + self.assertEqual(ret, 0, ("Failed to create snapshot %s for %s" + % (snapname, self.volname))) + sleep(1) + g.log.info("Snapshots created successfully for volume %s", + self.volname) + + # Validate snapshot list for 256 snapshots snap_list = get_snap_list(self.mnode) - self.assertTrue((len(snap_list) == 256), "No of snaps not consistent " - "for volume %s" % self.volname) - g.log.info("Successfully validated number of snaps.") - - # Validate all 256 snap names created during - for i in range(1, 257, 1): - self.assertTrue(("snapy%s" % i in snap_list), "%s snap not " - "found " % ("snapy%s" % i)) - g.log.info("Successfully validated names of snap") - - # Try to create 257th snapshot - cmd_str = "gluster snapshot create %s %s %s" % ("snap", self.volname, - "no-timestamp") - ret = g.run(self.mnode, cmd_str) - self.assertEqual(ret, 1, ("Unexpected: Successfully created 'snap'" - " for volume %s" % self.volname)) - g.log.info("Snapshot 'snap' not created as it is 257th snap") - - # Check for no. of snaps using snap_list it should be 256 + self.assertTrue((len(snap_list) == 256), "Failed: Number of snapshots " + "is not consistent for volume %s" % self.volname) + g.log.info("Successfully validated number of snapshots") + + # Validate snapshot existence using snap-name + for snapname in self.snapshots: + self.assertIn(snapname, snap_list, + "Failed: Snapshot %s not found" % snapname) + g.log.info("Successfully validated snapshots existence using " + "snap-name") + + # Try to exceed snap-max-hard-limit by creating 257th snapshot + snap_257 = "snap-test-validate-256-snapshots-%s-257" % (self.volname) + ret, _, _ = snap_create(self.mnode, self.volname, snap_257) + self.assertEqual( + ret, 1, ("Unexpected: Successfully created %s for volume %s" + % (snap_257, self.volname))) + g.log.info("Snapshot %s not created as it exceeds the " + "snap-max-hard-limit", snap_257) + + # Validate snapshot list for 256 snapshots snap_list = get_snap_list(self.mnode) - self.assertEqual(256, len(snap_list), "No of snaps not consistent " - "for volume %s" % self.volname) - g.log.info("Successfully validated number of snaps.") + self.assertEqual(len(snap_list), 256, "Failed: Number of snapshots " + "is not consistent for volume %s" % self.volname) + g.log.info("Successfully validated number of snapshots") -- cgit