def test_auth_allow_with_rebalance(self):
"""
Validating the FUSE authentication volume options with rebalance
Steps:
1. Setup and start volume
2. Set auth.allow on volume for client1 using ip of client1
3. Mount volume on client1.
4. Create files on mount point using dd command
5. Perform add brick operation
6. Trigger rebalance
7. Set auth.allow on volume for client1 using hostname of client1.
8. Repeat steps from 3 to 7
"""
# Setting authentication on volume for client1 using ip
auth_dict = {'all': [self.mounts[0].client_system]}
ret = set_auth_allow(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set authentication")
# Mounting volume on client1
self._authenticated_mount(self.mounts[0])
# Create files,perform add-brick,trigger rebalance
self._add_brick_rebalance()
# Unmount volume from client1
ret = self.mounts[0].unmount()
self.assertTrue(ret, ("Failed to unmount volume %s from client %s"
% (self.volname, self.mounts[0].client_system)))
# Obtain hostname of client1
ret, hostname_client1, _ = g.run(self.mounts[0].client_system,
"hostname")
self.assertEqual(ret, 0, ("Failed to obtain hostname of client %s"
% self.mounts[0].client_system))
g.log.info("Obtained hostname of client. IP- %s, hostname- %s",
self.mounts[0].client_system, hostname_client1.strip())
# Setting authentication on volume for client1 using hostname
auth_dict = {'all': [hostname_client1.strip()]}
ret = set_auth_allow(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set authentication")
# Mounting volume on client1
self._authenticated_mount(self.mounts[0])
# Create files,perform add-brick and trigger rebalance
self._add_brick_rebalance()
def test_subdir_with_quota_limit(self):
# pylint: disable=too-many-statements
"""
Mount the volume
Create 2 subdir on mount point
dir1-> /level1/subdir1 dir2->/dlevel1/dlevel2/dlevel3/subdir2
Auth allow - Client1(/level1/subdir1),
Client2(/dlevel1/dlevel2/dlevel3/subdir2)
Mount the subdir1 on client 1 and subdir2 on client2
Enable Quota
Verify Quota is enabled on volume
Set quota limit as 1GB and 2GB on both subdirs respectively
Perform a quota list operation
Perform IO's on both subdir until quota limit is almost hit for subdir1
Again Perform a quota list operation
Run IO's on Client 1.This should fail
Run IO's on Client2.This should pass
"""
# Create deep subdirectories subdir1 and subdir2 on mount point
ret = mkdir(self.mounts[0].client_system,
"%s/level1/subdir1" % self.mounts[0].mountpoint,
parents=True)
self.assertTrue(
ret, ("Failed to create directory '/level1/subdir1' on"
"volume %s from client %s" %
(self.mounts[0].volname, self.mounts[0].client_system)))
ret = mkdir(self.mounts[0].client_system,
"%s/dlevel1/dlevel2/dlevel3/subdir2" %
self.mounts[0].mountpoint,
parents=True)
self.assertTrue(
ret, ("Failed to create directory "
"'/dlevel1/dlevel2/dlevel3/subdir2' on"
"volume %s from client %s" %
(self.mounts[0].volname, self.mounts[0].client_system)))
# unmount volume
ret = self.unmount_volume(self.mounts)
self.assertTrue(ret, "Volumes Unmount failed")
g.log.info("Volumes Unmounted successfully")
# Set authentication on the subdirectory subdir1
# and subdir2
g.log.info(
'Setting authentication on directories subdir1 and subdir2'
'for client %s and %s', self.clients[0], self.clients[1])
ret = set_auth_allow(
self.volname, self.mnode, {
'/level1/subdir1': [self.clients[0]],
'/dlevel1/dlevel2/dlevel3/subdir2': [self.clients[1]]
})
self.assertTrue(
ret, 'Failed to set Authentication on volume %s' % self.volume)
# Creating mount list for subdirectories
self.subdir_mounts = [
copy.deepcopy(self.mounts[0]),
copy.deepcopy(self.mounts[1])
]
self.subdir_mounts[0].volname = "%s/level1/subdir1" % self.volname
self.subdir_mounts[1].volname = ("%s/dlevel1/dlevel2/dlevel3/subdir2" %
self.volname)
# Mount Subdirectory "subdir1" on client 1 and "subdir2" on client 2
for mount_obj in self.subdir_mounts:
ret = mount_obj.mount()
self.assertTrue(
ret, ("Failed to mount %s on client"
" %s" % (mount_obj.volname, mount_obj.client_system)))
g.log.info("Successfully mounted %s on client %s",
mount_obj.volname, mount_obj.client_system)
g.log.info("Successfully mounted subdirectories on client1"
"and clients 2")
# Enable quota on volume
g.log.info("Enabling quota on the volume %s", self.volname)
ret, _, _ = quota_enable(self.mnode, self.volname)
self.assertEqual(ret, 0, ("Failed to enable quota on the volume "
"%s", self.volname))
g.log.info("Successfully enabled quota on the volume %s", self.volname)
# Check if quota is enabled
g.log.info("Validate Quota is enabled on the volume %s", self.volname)
ret = is_quota_enabled(self.mnode, self.volname)
self.assertTrue(
ret, ("Quota is not enabled on the volume %s", self.volname))
g.log.info("Successfully Validated quota is enabled on volume %s",
self.volname)
# Setting up path to set quota limit
path1 = "/level1/subdir1"
path2 = "/dlevel1/dlevel2/dlevel3/subdir2"
# Set Quota limit on the subdirectory "subdir1"
g.log.info("Set Quota Limit on the path %s of the volume %s", path1,
self.volname)
ret, _, _ = quota_limit_usage(self.mnode,
self.volname,
path1,
limit="1GB")
self.assertEqual(ret, 0, ("Failed to set quota limit on path %s of "
" the volume %s", path1, self.volname))
g.log.info(
"Successfully set the Quota limit on %s of the volume "
"%s", path1, self.volname)
# Set Quota limit on the subdirectory "subdir2"
g.log.info("Set Quota Limit on the path %s of the volume %s", path2,
self.volname)
ret, _, _ = quota_limit_usage(self.mnode,
self.volname,
path2,
limit="2GB")
self.assertEqual(ret, 0, ("Failed to set quota limit on path %s of "
" the volume %s", path2, self.volname))
g.log.info(
"Successfully set the Quota limit on %s of the volume "
"%s", path2, self.volname)
# Get Quota List on the volume
g.log.info("Get Quota list on the volume %s", self.volname)
quota_list = quota_fetch_list(self.mnode, self.volname)
self.assertIsNotNone(quota_list, ("Failed to get the quota list "
"of the volume %s", self.volname))
# Check for subdir1 path in quota list
self.assertIn(
path1, quota_list.keys(),
("%s not part of the quota list %s even if "
"it is set on the volume %s", path1, quota_list, self.volname))
# Check for subdir2 path in quota list
self.assertIn(
path2, quota_list.keys(),
("%s not part of the quota list %s even if "
"it is set on the volume %s", path2, quota_list, self.volname))
g.log.info("Successfully listed quota list %s of the "
"volume %s", quota_list, self.volname)
# Create near to 1GB of data on both subdir mounts
for mount_object in self.subdir_mounts:
g.log.info("Creating Files on %s:%s", mount_object.client_system,
mount_object.mountpoint)
cmd = ("cd %s ; for i in `seq 1 1023` ;"
"do dd if=/dev/urandom of=file$i bs=1M "
"count=1;done" % (mount_object.mountpoint))
ret, _, _ = g.run(mount_object.client_system, cmd)
self.assertEqual(ret, 0, "Failed to create files on mountpoint")
g.log.info("Files created successfully on mountpoint")
# Again Get Quota List on the volume
g.log.info("Get Quota list on the volume %s", self.volname)
quota_list = quota_fetch_list(self.mnode, self.volname)
self.assertIsNotNone(quota_list, ("Failed to get the quota list "
"of the volume %s", self.volname))
# Check for subdir1 path in quota list
self.assertIn(
path1, quota_list.keys(),
("%s not part of the quota list %s even if "
"it is set on the volume %s", path1, quota_list, self.volname))
# Check for subdir2 path in quota list
self.assertIn(
path2, quota_list.keys(),
("%s not part of the quota list %s even if "
"it is set on the volume %s", path2, quota_list, self.volname))
g.log.info("Successfully listed quota list %s of the "
"volume %s", quota_list, self.volname)
# Again run IO's to check if quota limit is adhere for subdir1
# Start IO's on subdir1
g.log.info("Creating Files on %s:%s", self.clients[0],
self.subdir_mounts[0].mountpoint)
cmd = ("cd %s ; for i in `seq 1024 1500` ;"
"do dd if=/dev/urandom of=file$i bs=1M "
"count=1;done" % (self.subdir_mounts[0].mountpoint))
ret, _, _ = g.run(self.clients[0], cmd)
if ret == 0:
raise ExecutionError("IO was expected to Fail."
"But it got passed")
else:
g.log.info(
"IO's failed as expected on %s:%s as quota "
"limit reached already", self.clients[0],
self.subdir_mounts[0].mountpoint)
# Start IO's on subdir2
g.log.info("Creating Files on %s:%s", self.clients[1],
self.subdir_mounts[1].mountpoint)
cmd = ("cd %s ; for i in `seq 1024 1500` ;"
"do dd if=/dev/urandom of=file$i bs=1M "
"count=1;done" % (self.subdir_mounts[1].mountpoint))
ret, _, _ = g.run(self.clients[1], cmd)
self.assertEqual(ret, 0,
("Failed to create files on %s" % self.clients[1]))
g.log.info("Files created successfully on %s:%s", self.clients[1],
self.subdir_mounts[1].mountpoint)
def test_auth_reject_allow(self):
"""
Verify auth.reject and auth.allow volume options in volume level using
both client ip and hostname.
Verify auth.reject and auth.allow volume options in sub-directory
level using both client ip and hostname.
Steps:
1. Create and start volume.
2. Set auth.reject on volume for client1 using ip of client1.
3. Set auth.allow on volume for client2 using ip of client2.
4. Try to mount volume on client1. This should fail.
5. Check the client1 log for AUTH_FAILED event.
6. Mount volume on client2.
7. Unmount the volume from client2.
8. Set auth.reject on volume for client1 using hostname of client1.
9. Set auth.allow on volume for client2 using hostname of client2.
10. Repeat steps 4 to 6
11. Create directory d1 on client2 mountpoint.
12. Unmount the volume from client2.
13. Set auth.reject on d1 for client1 using ip of client1.
14. Set auth.allow on d1 for client2 using ip of client2.
15. Try to mount d1 on client1. This should fail.
16. Check the client1 log for AUTH_FAILED event.
17. Mount d1 on client2.
18. Unmount d1 from client2.
19. Set auth.reject on d1 for client1 using hostname of client1.
20. Set auth.allow on d1 for client2 using hostname of client2.
21. Repeat steps 15 to 18.
"""
# pylint: disable = too-many-statements
# Setting auth.reject on volume for client1 using ip
auth_dict = {'all': [self.mounts[0].client_system]}
ret = set_auth_reject(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set auth.reject volume option.")
g.log.info("Successfully set auth.reject option on volume")
# Setting auth.allow on volume for client2 using ip
auth_dict = {'all': [self.mounts[1].client_system]}
ret = set_auth_allow(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set auth.allow volume option")
g.log.info("Successfully set auth.allow option on volume")
# Trying to mount volume on client1
self.unauthenticated_mount(self.mounts[0])
# Verify whether mount failure on client1 is due to auth error
log_msg = self.is_auth_failure(self.mounts[0].client_system)
prev_log_statement = log_msg
# Mounting volume on client2
self.authenticated_mount(self.mounts[1])
g.log.info("Verification of auth.reject and auth.allow options on "
"volume using client IP is successful")
# Unmount volume from client2
ret = self.mounts[1].unmount()
self.assertTrue(ret, ("Failed to unmount volume %s from client %s" %
(self.volname, self.mounts[1].client_system)))
# Obtain hostname of client1
ret, hostname_client1, _ = g.run(self.mounts[0].client_system,
"hostname")
self.assertEqual(ret, 0, ("Failed to obtain hostname of client %s" %
self.mounts[0].client_system))
g.log.info("Obtained hostname of client. IP- %s, hostname- %s",
self.mounts[0].client_system, hostname_client1.strip())
# Obtain hostname of client2
ret, hostname_client2, _ = g.run(self.mounts[1].client_system,
"hostname")
self.assertEqual(ret, 0, ("Failed to obtain hostname of client %s" %
self.mounts[1].client_system))
g.log.info("Obtained hostname of client. IP- %s, hostname- %s",
self.mounts[1].client_system, hostname_client2.strip())
# Setting auth.reject on volume for client1 using hostname
auth_dict = {'all': [hostname_client1.strip()]}
ret = set_auth_reject(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set auth.reject volume option.")
g.log.info("Successfully set auth.reject option on volume")
# Setting auth.allow on volume for client2 using hostname
auth_dict = {'all': [hostname_client2.strip()]}
ret = set_auth_allow(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set auth.allow volume option")
g.log.info("Successfully set auth.allow option on volume")
# Trying to mount volume on client1
self.unauthenticated_mount(self.mounts[0])
# Verify whether mount failure on client1 is due to auth error
log_msg = self.is_auth_failure(self.mounts[0].client_system,
prev_log_statement)
prev_log_statement = log_msg
# Mounting volume on client2
self.authenticated_mount(self.mounts[1])
g.log.info("Verification of auth.reject and auth.allow options on "
"volume using client hostname is successful")
# Creating sub directory d1 on mounted volume
ret = mkdir(self.mounts[1].client_system,
"%s/d1" % self.mounts[1].mountpoint)
self.assertTrue(ret, ("Failed to create directory 'd1' in volume %s "
"from client %s" %
(self.volname, self.mounts[1].client_system)))
# Unmount volume from client2
ret = self.mounts[1].unmount()
self.assertTrue(ret, ("Failed to unmount volume %s from client %s" %
(self.volname, self.mounts[1].client_system)))
# Setting auth.reject on d1 for client1 using ip
auth_dict = {'/d1': [self.mounts[0].client_system]}
ret = set_auth_reject(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set auth.reject volume option.")
g.log.info("Successfully set auth.reject option.")
# Setting auth.allow on d1 for client2 using ip
auth_dict = {'/d1': [self.mounts[1].client_system]}
ret = set_auth_allow(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set auth.allow volume option")
g.log.info("Successfully set auth.allow option.")
# Creating mount object for sub-directory mount on client1
mount_obj_client1 = copy.deepcopy(self.mounts[0])
mount_obj_client1.volname = "%s/d1" % self.volname
# Creating mount object for sub-directory mount on client2
mount_obj_client2 = copy.deepcopy(self.mounts[1])
mount_obj_client2.volname = "%s/d1" % self.volname
# Trying to mount d1 on client1
self.unauthenticated_mount(mount_obj_client1)
# Verify whether mount failure on client1 is due to auth error
log_msg = self.is_auth_failure(mount_obj_client1.client_system,
prev_log_statement)
prev_log_statement = log_msg
# Mounting d1 on client2
self.authenticated_mount(mount_obj_client2)
g.log.info("Verification of auth.reject and auth.allow options on "
"sub-directory level using client IP is successful")
# Unmount d1 from client2
ret = mount_obj_client2.unmount()
self.assertTrue(
ret,
("Failed to unmount %s from client %s" %
(mount_obj_client2.volname, mount_obj_client2.client_system)))
# Setting auth.reject on d1 for client1 using hostname
auth_dict = {'/d1': [hostname_client1.strip()]}
ret = set_auth_reject(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set auth.reject volume option.")
g.log.info("Successfully set auth.reject option.")
# Setting auth.allow on d1 for client2 using hostname
auth_dict = {'/d1': [hostname_client2.strip()]}
ret = set_auth_allow(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set auth.allow volume option")
g.log.info("Successfully set auth.allow option.")
# Trying to mount d1 on client1
self.unauthenticated_mount(mount_obj_client1)
# Verify whether mount failure on client1 is due to auth error
self.is_auth_failure(mount_obj_client1.client_system,
prev_log_statement)
# Mounting d1 on client2
self.authenticated_mount(mount_obj_client2)
g.log.info("Verification of auth.reject and auth.allow options on "
"sub-directory level using client hostname is successful")
# Unmount d1 from client2
ret = mount_obj_client2.unmount()
self.assertTrue(
ret,
("Failed to unmount %s from client %s" %
(mount_obj_client2.volname, mount_obj_client2.client_system)))
def test_subdir_with_addbrick(self):
# pylint: disable=too-many-statements
"""
Mount the volume
Create 2 subdir on mount point, subdir1 and subdir2
Auth allow - Client1(subdir1,subdir2),Client2(subdir1,subdir2)
Mount the subdir1 on client 1 and subdir2 on client2
Start IO's on both subdirs
Perform add-brick and rebalance
"""
# Create directories subdir1 and subdir2 on mount point
ret = mkdir(self.mounts[0].client_system,
"%s/subdir1" % self.mounts[0].mountpoint)
self.assertTrue(
ret, ("Failed to create directory 'subdir1' on"
"volume %s from client %s" %
(self.mounts[0].volname, self.mounts[0].client_system)))
ret = mkdir(self.mounts[0].client_system,
"%s/subdir2" % self.mounts[0].mountpoint)
self.assertTrue(
ret, ("Failed to create directory 'subdir2' on"
"volume %s from client %s" %
(self.mounts[0].volname, self.mounts[0].client_system)))
# unmount volume
ret = self.unmount_volume(self.mounts)
self.assertTrue(ret, "Volumes Unmount failed")
g.log.info("Volumes Unmounted successfully")
# Set authentication on the subdirectory subdir1
# and subdir2 to access by 2 clients
g.log.info(
'Setting authentication on subdir1 and subdir2'
'for client %s and %s', self.clients[0], self.clients[0])
ret = set_auth_allow(
self.volname, self.mnode, {
'/subdir1': [self.clients[0], self.clients[1]],
'/subdir2': [self.clients[0], self.clients[1]]
})
self.assertTrue(
ret, 'Failed to set Authentication on volume %s' % self.volume)
# Creating mount list for subdirectories
self.subdir_mounts = [
copy.deepcopy(self.mounts[0]),
copy.deepcopy(self.mounts[1])
]
self.subdir_mounts[0].volname = "%s/subdir1" % self.volname
self.subdir_mounts[1].volname = "%s/subdir2" % self.volname
# Mount Subdirectory "subdir1" on client 1 and "subdir2" on client 2
for mount_obj in self.subdir_mounts:
ret = mount_obj.mount()
self.assertTrue(
ret, ("Failed to mount %s on client"
" %s" % (mount_obj.volname, mount_obj.client_system)))
g.log.info("Successfully mounted %s on client %s",
mount_obj.volname, mount_obj.client_system)
g.log.info("Successfully mounted subdirectories on client1"
"and clients 2")
# Start IO on all mounts.
all_mounts_procs = []
count = 1
for mount_obj in self.subdir_mounts:
g.log.info("Starting IO on %s:%s", mount_obj.client_system,
mount_obj.mountpoint)
cmd = ("/usr/bin/env python %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" %
(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.subdir_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.")
ret = get_mounts_stat(self.subdir_mounts)
self.assertTrue(ret, "Stat failed on some of the clients")
g.log.info("Successfully got stat of all files/dirs created")
# Start add-brick (subvolume-increase)
g.log.info("Start adding bricks to volume when IO in progress")
ret = expand_volume(self.mnode, self.volname, self.servers,
self.all_servers_info)
self.assertTrue(ret, ("Failed to expand the volume when IO in "
"progress on volume %s", self.volname))
g.log.info(
"Expanding volume when IO in progress is successful on "
"volume %s", self.volname)
# Log Volume Info and Status after expanding the volume
g.log.info("Logging volume info and Status after expanding volume")
ret = log_volume_info_and_status(self.mnode, self.volname)
self.assertTrue(ret, ("Logging volume info and status failed on "
"volume %s", self.volname))
g.log.info("Successful in logging volume info and status of volume %s",
self.volname)
# Wait for volume processes to be online
g.log.info("Wait for volume processes to be online")
ret = wait_for_volume_process_to_be_online(self.mnode, self.volname)
self.assertTrue(ret, ("All process for volume %s are not"
"online", self.volname))
g.log.info("All volume %s processes are now online", self.volname)
# Start Rebalance
g.log.info("Starting Rebalance on the volume")
ret, _, _ = rebalance_start(self.mnode, self.volname)
self.assertEqual(ret, 0, ("Failed to start rebalance on the volume "
"%s", self.volname))
g.log.info("Successfully started rebalance on the volume %s",
self.volname)
# Wait for rebalance to complete
g.log.info("Waiting for rebalance to complete")
ret = wait_for_rebalance_to_complete(self.mnode, self.volname, 600)
self.assertTrue(
ret, "Rebalance did not complete "
"despite waiting for 10 minutes")
g.log.info("Rebalance successfully completed on the volume %s",
self.volname)
# Again validate if subdirectories are still mounted post add-brick
for mount_obj in self.subdir_mounts:
ret = mount_obj.is_mounted()
self.assertTrue(
ret, ("Subdirectory %s is not mounted on client"
" %s" % (mount_obj.volname, mount_obj.client_system)))
g.log.info("Subdirectory %s is mounted on client %s",
mount_obj.volname, mount_obj.client_system)
g.log.info("Successfully validated that subdirectories are mounted"
"on client1 and clients 2 post add-brick operation")
def test_verify_auth_reject_precedence(self):
"""
This testcase verifies the precedence of auth.reject volume option
over auth.allow volume option.
Verification will be done in volume level and sub-directory level
using both IP and hostname.
Steps:
1. Create and start volume.
2. Mount volume on client1.
3. Create directory d1 on client1 mountpoint.
4. Unmount volume from client1.
5. Set auth.reject on volume for all clients(*).
6. Set auth.allow on volume for client1 and client2 using ip.
7. Try to mount volume on client1. This should fail.
8. Check the client1 log for AUTH_FAILED event.
9. Try to mount volume on client2. This should fail.
10. Check the client2 log for AUTH_FAILED event.
11. Set auth.allow on volume for client1 and client2 using hostname.
12. Repeat steps 7 to 10.
13. Set auth.reject on sub-directory d1 for all clients(*).
14. Set auth.allow on sub-directory d1 for client1 and client2 using
ip.
15. Try to mount d1 on client1. This should fail.
16. Check the client1 log for AUTH_FAILED event.
17. Try to mount d1 on client2. This should fail.
18. Check the client2 log for AUTH_FAILED event.
19. Set auth.allow on sub-directory d1 for client1 and client2 using
hostname.
20. Repeat steps 15 to 18.
"""
# pylint: disable = too-many-statements
# Mounting volume on client1
self.authenticated_mount(self.mounts[0])
# Creating sub directory d1 on mounted volume
ret = mkdir(self.mounts[0].client_system,
"%s/d1" % self.mounts[0].mountpoint)
self.assertTrue(ret, ("Failed to create directory 'd1' in volume %s "
"from client %s" %
(self.volname, self.mounts[0].client_system)))
# Unmount volume from client1
ret = self.mounts[0].unmount()
self.assertTrue(ret, ("Failed to unmount volume %s from client %s" %
(self.volname, self.mounts[0].client_system)))
# Setting auth.reject on volume for all clients
auth_dict = {'all': ['*']}
ret = set_auth_reject(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set auth.reject volume option.")
g.log.info("Successfully set auth.reject option on volume")
# Setting auth.allow on volume for client1 and client2 using ip
auth_dict = {
'all':
[self.mounts[0].client_system, self.mounts[0].client_system]
}
ret = set_auth_allow(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set auth.allow volume option")
g.log.info("Successfully set auth.allow option on volume")
# Trying to mount volume on client1
self.unauthenticated_mount(self.mounts[0])
# Verify whether mount failure on client1 is due to auth error
log_msg = self.is_auth_failure(self.mounts[0].client_system)
prev_log_statement_c1 = log_msg
# Trying to mount volume on client2
self.unauthenticated_mount(self.mounts[1])
# Verify whether mount failure on client2 is due to auth error
log_msg = self.is_auth_failure(self.mounts[1].client_system)
prev_log_statement_c2 = log_msg
g.log.info("Verification of auth.reject precedence over auth.allow"
"option on volume using clients' ip is successful")
# Obtain hostname of client1
ret, hostname_client1, _ = g.run(self.mounts[0].client_system,
"hostname")
hostname_client1 = hostname_client1.strip()
self.assertEqual(ret, 0, ("Failed to obtain hostname of client %s" %
self.mounts[0].client_system))
g.log.info("Obtained hostname of client. IP- %s, hostname- %s",
self.mounts[0].client_system, hostname_client1)
# Obtain hostname of client2
ret, hostname_client2, _ = g.run(self.mounts[1].client_system,
"hostname")
hostname_client2 = hostname_client2.strip()
self.assertEqual(ret, 0, ("Failed to obtain hostname of client %s" %
self.mounts[1].client_system))
g.log.info("Obtained hostname of client. IP- %s, hostname- %s",
self.mounts[1].client_system, hostname_client2)
# Setting auth.allow on volume for client1 and client2 using hostname
auth_dict = {'all': [hostname_client1, hostname_client2]}
ret = set_auth_allow(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set auth.allow volume option")
g.log.info("Successfully set auth.allow option on volume")
# Trying to mount volume on client1
self.unauthenticated_mount(self.mounts[0])
# Verify whether mount failure on client1 is due to auth error
log_msg = self.is_auth_failure(self.mounts[0].client_system,
prev_log_statement_c1)
prev_log_statement_c1 = log_msg
# Trying to mount volume on client2
self.unauthenticated_mount(self.mounts[1])
# Verify whether mount failure on client2 is due to auth error
log_msg = self.is_auth_failure(self.mounts[1].client_system,
prev_log_statement_c2)
prev_log_statement_c2 = log_msg
g.log.info("Verification of auth.reject precedence over auth.allow"
"option on volume using clients' hostname is successful")
# Setting auth.reject on d1 for all clients
auth_dict = {'/d1': ['*']}
ret = set_auth_reject(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set auth.reject volume option.")
g.log.info("Successfully set auth.reject option.")
# Setting auth.allow on d1 for client1 and client2 using ip
auth_dict = {
'/d1':
[self.mounts[0].client_system, self.mounts[1].client_system]
}
ret = set_auth_allow(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set auth.allow volume option")
g.log.info("Successfully set auth.allow option.")
# Creating mount object for sub-directory mount on client1
mount_obj_client1 = copy.deepcopy(self.mounts[0])
mount_obj_client1.volname = "%s/d1" % self.volname
# Creating mount object for sub-directory mount on client2
mount_obj_client2 = copy.deepcopy(self.mounts[1])
mount_obj_client2.volname = "%s/d1" % self.volname
# Trying to mount d1 on client1
self.unauthenticated_mount(mount_obj_client1)
# Verify whether mount failure on client1 is due to auth error
log_msg = self.is_auth_failure(mount_obj_client1.client_system,
prev_log_statement_c1)
prev_log_statement_c1 = log_msg
# Trying to mount d1 on client2
self.unauthenticated_mount(mount_obj_client2)
# Verify whether mount failure on client2 is due to auth error
log_msg = self.is_auth_failure(mount_obj_client2.client_system,
prev_log_statement_c2)
prev_log_statement_c2 = log_msg
g.log.info("Verification of auth.reject precedence over auth.allow"
"option on sub-directory level using clients' ip is "
"successful")
# Setting auth.allow on d1 for client1 and client2 using hostname
auth_dict = {'/d1': [hostname_client1, hostname_client2]}
ret = set_auth_allow(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set auth.allow volume option")
g.log.info("Successfully set auth.allow option.")
# Trying to mount d1 on client1
self.unauthenticated_mount(mount_obj_client1)
# Verify whether mount failure on client1 is due to auth error
self.is_auth_failure(mount_obj_client1.client_system,
prev_log_statement_c1)
# Trying to mount d1 on client2
self.unauthenticated_mount(mount_obj_client2)
# Verify whether mount failure on client2 is due to auth error
self.is_auth_failure(mount_obj_client2.client_system,
prev_log_statement_c2)
g.log.info("Verification of auth.reject precedence over auth.allow"
"option on sub-directory level using clients' hostname is "
"successful")
def test_subdir_when_renamed(self):
# pylint: disable=too-many-statements
"""
Mount the volume
Create 1 subdir on mountpoint "d1"
Auth allow - Client1(d1),Client2(full volume)
Mount the subdir "d1" on client1 and volume on client2
Start IO's on all the mount points
Perform rename operation from client2.Rename the subdir
"d1" to "d1_renamed"
unmount volume and subdir from clients
Try mounting "d1" on client 1.This should fail.
Try mounting "d1_renamed" on client 1.This should fail.
Again set authentication.Auth allow -
Client1(d1_renamed),Client2(full volume)
Mount "d1_renamed" on client1 and volume on client2
"""
# Create directory d1 on mount point
ret = mkdir(self.mounts[0].client_system,
"%s/d1" % self.mounts[0].mountpoint)
self.assertTrue(
ret, ("Failed to create directory 'd1' on"
"volume %s from client %s" %
(self.mounts[0].volname, self.mounts[0].client_system)))
# unmount volume
ret = self.unmount_volume(self.mounts)
self.assertTrue(ret, "Volumes Unmount failed")
g.log.info("Volumes Unmounted successfully")
# Set authentication on the subdirectoy "d1" to access by client1
# and volume to access by client2
g.log.info(
'Setting authentication on subdirectory d1 to access'
'by client %s and on volume to access by client %s',
self.clients[0], self.clients[1])
ret = set_auth_allow(self.volname, self.mnode, {
'/d1': [self.clients[0]],
'/': [self.clients[1]]
})
self.assertTrue(
ret, 'Failed to set Authentication on volume %s' % self.volume)
# Creating mount list for mounting subdir mount and volume
self.subdir_mounts = [
copy.deepcopy(self.mounts[0]),
copy.deepcopy(self.mounts[1])
]
self.subdir_mounts[0].volname = "%s/d1" % self.volname
self.subdir_mounts[0].client_system = self.clients[0]
self.subdir_mounts[1].client_system = self.clients[1]
# Mount Subdirectory d1 on client 1 and volume on client 2
for mount_obj in self.subdir_mounts:
mountpoint = mount_obj.mountpoint
ret = mount_obj.mount()
self.assertTrue(
ret, ("Failed to mount %s on client"
" %s" % (mount_obj.volname, mount_obj.client_system)))
g.log.info("Successfully mounted %s on client %s",
mount_obj.volname, mount_obj.client_system)
g.log.info("Successfully mounted sub directory and volume to"
"authenticated clients")
# Start IO on all the mounts.
all_mounts_procs = []
count = 1
for mount_obj in self.subdir_mounts:
g.log.info("Starting IO on %s:%s", mount_obj.client_system,
mount_obj.mountpoint)
cmd = ("python %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" %
(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.subdir_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.")
ret = get_mounts_stat(self.subdir_mounts)
self.assertTrue(ret, "Stat failed on some of the clients")
g.log.info("Successfully got stat of all files/dirs created")
# Rename the subdir "d1" to "d1_renamed" from client2
source_fpath = "%s/d1" % mountpoint
dest_fpath = "%s/d1_renamed" % mountpoint
ret = move_file(self.clients[1], source_fpath, dest_fpath)
self.assertTrue(ret, "Rename subdirectory failed")
g.log.info('Renamed directory %s to %s', source_fpath, dest_fpath)
# unmount volume and subdir from client
ret = self.unmount_volume(self.subdir_mounts)
self.assertTrue(ret, "Volumes UnMount failed")
g.log.info("Volumes Unmounted successfully")
# Try mounting subdir "d1" on client1
_, _, _ = mount_volume("%s/d1" % self.volname, self.mount_type,
mountpoint, self.mnode, self.clients[0])
ret = is_mounted(self.volname, mountpoint, self.mnode, self.clients[0],
self.mount_type)
self.assertEqual(
ret, 0, "d1 mount should have failed.But d1 is"
"successfully mounted on mount point: %s" % mountpoint)
g.log.info("subdir %s/d1 is not mounted as expected %s", self.volname,
mountpoint)
# Try mounting subdir "d1_renamed" on client1
_, _, _ = mount_volume("%s/d1_renamed" % self.volname, self.mount_type,
mountpoint, self.mnode, self.clients[0])
ret = is_mounted("%s/d1_renamed" % self.volname, mountpoint,
self.mnode, self.clients[0], self.mount_type)
self.assertEqual(
ret, 0, "d1_renamed mount should have failed.But"
"d1_renamed is successfully mounted on : %s" % mountpoint)
g.log.info("subdir %s/d1_renamed is not mounted as expected %s",
self.volname, mountpoint)
# Set authentication on the subdirectoy "d1_renamed" to access
# by client1 and volume to access by client2
g.log.info(
'Setting authentication on subdirectory d1_renamed to'
'access by client %s and on volume to access by client %s',
self.clients[0], self.clients[1])
ret = set_auth_allow(self.volname, self.mnode, {
'/d1_renamed': [self.clients[0]],
'/': [self.clients[1]]
})
self.assertTrue(
ret, 'Failed to set Authentication on volume %s' % self.volume)
# Overwriting the list of subdir mount, directory d1 to d1_renamed
self.subdir_mounts[0].volname = "%s/d1_renamed" % self.volname
# Mount Subdirectory d1_renamed on client 1 and volume on client 2
for mount_obj in self.subdir_mounts:
ret = mount_obj.mount()
self.assertTrue(
ret, ("Failed to mount %s on client"
" %s" % (mount_obj.volname, mount_obj.client_system)))
g.log.info("Successfully mounted %s on client %s",
mount_obj.volname, mount_obj.client_system)
g.log.info("Successfully mounted sub directory and volume to"
"authenticated clients")
# Get stat of all the files/dirs created from both clients.
g.log.info("Get stat of all the files/dirs created.")
ret = get_mounts_stat(self.subdir_mounts)
self.assertTrue(ret, "Stat failed on some of the clients")
g.log.info("Successfully got stat of all files/dirs created")
def test_auth_allow(self):
"""
Verify auth.allow feature using client ip and hostname.
Steps:
1. Setup and start volume
2. Set auth.allow on volume for client1 using ip of client1
3. Mount volume on client1.
4. Try to mount volume on client2. This should fail.
5. Check the client2 logs for AUTH_FAILED event.
6. Unmount the volume from client1.
7. Set auth.allow on volume for client1 using hostname of client1.
8. Repeat steps 3 to 5.
9. Unmount the volume from client1.
"""
# Setting authentication on volume for client1 using ip
auth_dict = {'all': [self.mounts[0].client_system]}
ret = set_auth_allow(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set authentication")
# Mounting volume on client1
self.authenticated_mount(self.mounts[0])
# Trying to mount volume on client2
self.unauthenticated_mount(self.mounts[1])
# Verify whether mount failure on client2 is due to auth error
log_msg = self.is_auth_failure(self.mounts[1].client_system)
prev_log_statement = log_msg
g.log.info("Verification of auth.allow on volume using client IP is "
"successful")
# Unmount volume from client1
ret = self.mounts[0].unmount()
self.assertTrue(ret, ("Failed to unmount volume %s from client %s" %
(self.volname, self.mounts[0].client_system)))
# Obtain hostname of client1
ret, hostname_client1, _ = g.run(self.mounts[0].client_system,
"hostname")
self.assertEqual(ret, 0, ("Failed to obtain hostname of client %s" %
self.mounts[0].client_system))
g.log.info("Obtained hostname of client. IP- %s, hostname- %s",
self.mounts[0].client_system, hostname_client1.strip())
# Setting authentication on volume for client1 using hostname
auth_dict = {'all': [hostname_client1.strip()]}
ret = set_auth_allow(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set authentication")
# Mounting volume on client1
self.authenticated_mount(self.mounts[0])
# Trying to mount volume on client2
self.unauthenticated_mount(self.mounts[1])
# Verify whether mount failure on client2 is due to auth error
log_msg = self.is_auth_failure(self.mounts[1].client_system,
prev_log_statement)
prev_log_statement = log_msg
g.log.info("Verification of auth.allow on volume using client "
"hostname is successful")
# Unmount volume from client1
ret = self.mounts[0].unmount()
self.assertTrue(ret, ("Failed to unmount volume %s from client %s" %
(self.volname, self.mounts[0].client_system)))
def test_subdir_with_removebrick(self):
# pylint: disable=too-many-statements
"""
Mount the volume
Create 2 subdir on client subdir1 and subdir2
Auth allow - Client1(subdir1,subdir2),Client2(subdir1,subdir2)
Mount the subdir to their respective clients
Start IO's on both subdirs
Perform remove-brick
Validate on client if subdir's are mounted post remove-brick
operation is performed
"""
# Create directories subdir1 and subdir2 on mount point
ret = mkdir(self.mounts[0].client_system,
"%s/subdir1" % self.mounts[0].mountpoint)
self.assertTrue(
ret, ("Failed to create directory 'subdir1' in"
"volume %s from client %s" %
(self.mounts[0].volname, self.mounts[0].client_system)))
ret = mkdir(self.mounts[0].client_system,
"%s/subdir2" % self.mounts[0].mountpoint)
self.assertTrue(
ret, ("Failed to create directory 'subdir2' in"
"volume %s from client %s" %
(self.mounts[0].volname, self.mounts[0].client_system)))
# unmount volume
ret = self.unmount_volume(self.mounts)
self.assertTrue(ret, "Volumes UnMount failed")
g.log.info("Volumes UnMounted successfully")
# Set authentication on the subdirectory subdir1
# and subdir2 to access by 2 clients
g.log.info(
'Setting authentication on subdir1 and subdir2'
'for client %s and %s', self.clients[0], self.clients[0])
ret = set_auth_allow(
self.volname, self.mnode, {
'/subdir1': [self.clients[0], self.clients[1]],
'/subdir2': [self.clients[0], self.clients[1]]
})
self.assertTrue(
ret, 'Failed to set Authentication on volume %s' % self.volume)
self.mpoint = "/mnt/Mount_Point1"
# Mount Subdir1 mount on client 1
_, _, _ = mount_volume("%s/subdir1" % self.volname, self.mount_type,
self.mpoint, self.mnode, self.clients[0])
# Checking subdir1 is mounted or not
ret = is_mounted("%s/subdir1" % self.volname, self.mpoint, self.mnode,
self.clients[0], self.mount_type)
self.assertTrue(ret,
"Volume not mounted on mount point: %s" % self.mpoint)
g.log.info("Volume %s mounted on %s/subdir1", self.volname,
self.mpoint)
# Mount Subdir2 mount on client 2
_, _, _ = mount_volume("%s/subdir2" % self.volname, self.mount_type,
self.mpoint, self.mnode, self.clients[1])
# Checking subdir2 is mounted or not
ret = is_mounted("%s/subdir2" % self.volname, self.mpoint, self.mnode,
self.clients[1], self.mount_type)
self.assertTrue(ret,
"Volume not mounted on mount point: %s" % self.mpoint)
g.log.info("Volume %s mounted on %s/subdir2", self.volname,
self.mpoint)
# Start IO on all the subdir mounts.
self.subdir_mounts = [
copy.deepcopy(self.mounts[0]),
copy.deepcopy(self.mounts[1])
]
self.subdir_mounts[0].volname = "%s/subdir1" % self.volname
self.subdir_mounts[1].volname = "%s/subdir2" % self.volname
all_mounts_procs = []
count = 1
for mount_obj in self.subdir_mounts:
g.log.info("Starting IO on %s:%s", mount_obj.client_system,
self.mpoint)
cmd = ("/usr/bin/env python %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" %
(self.script_upload_path, count, self.mpoint))
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.subdir_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.")
ret = get_mounts_stat(self.subdir_mounts)
self.assertTrue(ret, "Stat failed on some of the clients")
g.log.info("Successfully got stat of all files/dirs created")
# Perform remove brick operation when subdir is mounted on client
g.log.info("Start removing bricks from volume")
ret = shrink_volume(self.mnode, self.volname, rebalance_timeout=600)
self.assertTrue(ret, ("Remove brick operation failed on "
"%s", self.volname))
g.log.info("Remove brick operation is successful on "
"volume %s", self.volname)
# Wait for volume processes to be online
g.log.info("Wait for volume processes to be online")
ret = wait_for_volume_process_to_be_online(self.mnode, self.volname)
self.assertTrue(ret, ("All volume %s processes failed to come up "
"online", self.volname))
g.log.info("All volume %s processes came up "
"online successfully", self.volname)
# Log Volume Info and Status after performing remove brick
g.log.info("Logging volume info and Status after shrinking volume")
ret = log_volume_info_and_status(self.mnode, self.volname)
self.assertTrue(ret, ("Logging volume info and status failed on "
"volume %s", self.volname))
g.log.info("Successful in logging volume info and status of volume %s",
self.volname)
# Again Checking subdir1 is mounted or not on Client 1
ret = is_mounted("%s/subdir1" % self.volname, self.mpoint, self.mnode,
self.clients[0], self.mount_type)
self.assertTrue(ret,
"Volume not mounted on mount point: %s" % self.mpoint)
g.log.info("Volume %s mounted on %s/subdir1", self.volname,
self.mpoint)
# Again Checking subdir2 is mounted or not on Client 2
ret = is_mounted("%s/subdir2" % self.volname, self.mpoint, self.mnode,
self.clients[1], self.mount_type)
self.assertTrue(ret,
"Volume not mounted on mount point: %s" % self.mpoint)
g.log.info("Volume %s mounted on %s/subdir2", self.volname,
self.mpoint)
def test_auth_allow_ip_fqdn(self):
"""
Verify auth.allow feature using a combination of client ip and fqdn.
Steps:
1. Setup and start volume
2. Set auth.allow on volume using ip of client1 and hostname of
client2.
3. Mount the volume on client1 and client2.
5. Create directory d1 on client1 mountpoint.
6. Unmount the volume from client1 and client2.
7. Set auth.allow on d1 using ip of client1 and hostname of client2.
8. Mount d1 on client1 and client2.
9. Unmount d1 from client1 and client2.
"""
# Obtain hostname of client2
ret, hostname_client2, _ = g.run(self.mounts[1].client_system,
"hostname")
self.assertEqual(ret, 0, ("Failed to obtain hostname of client %s" %
self.mounts[1].client_system))
hostname_client2 = hostname_client2.strip()
g.log.info("Obtained hostname of client. IP- %s, hostname- %s",
self.mounts[1].client_system, hostname_client2)
# Setting authentication on volume using ip of client1 and hostname of
# client2.
auth_dict = {'all': [self.mounts[0].client_system, hostname_client2]}
ret = set_auth_allow(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set authentication")
g.log.info("Successfully set authentication on volume")
# Mount volume on client1
self.mount_and_verify(self.mounts[0])
# Mount volume on client2
self.mount_and_verify(self.mounts[1])
g.log.info("Successfully mounted volume on client1 and client2.")
# Creating directory d1 on mounted volume
ret = mkdir(self.mounts[0].client_system,
"%s/d1" % self.mounts[0].mountpoint)
self.assertTrue(ret, ("Failed to create directory 'd1' in volume %s "
"from client %s" %
(self.volname, self.mounts[0].client_system)))
# Unmount volume from client1.
ret = self.mounts[0].unmount()
self.assertTrue(ret, "Failed to unmount volume from client1.")
# Unmount volume from client2.
ret = self.mounts[1].unmount()
self.assertTrue(ret, "Failed to unmount volume from client2.")
# Setting authentication on d1 using ip of client1 and hostname of
# client2.
auth_dict = {'/d1': [self.mounts[0].client_system, hostname_client2]}
ret = set_auth_allow(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set authentication")
g.log.info("Successfully set authentication on volume")
# Modify GlusterMount objects for mounting sub-directory d1.
self.mounts[0].volname = "%s/d1" % self.volname
self.mounts[1].volname = "%s/d1" % self.volname
# Mount sub-directory d1 on client1
self.mount_and_verify(self.mounts[0])
# Mount sub-directory d1 on client2
self.mount_and_verify(self.mounts[1])
g.log.info("Successfully mounted sub-dir d1 on client1 and client2.")
# Unmount sub-directory d1 from client1.
ret = self.mounts[0].unmount()
self.assertTrue(ret, "Failed to unmount volume from client1.")
# Unmount sub-directory d1 from client2.
ret = self.mounts[1].unmount()
self.assertTrue(ret, "Failed to unmount volume from client2.")
def test_node_reboot_subdir_mounted_io_running(self):
"""
Verify node reboot operation when sub-dirs are mounted and IOs are
running
Steps:
1. Create two sub-directories on mounted volume.
2. Un mount volume from clients.
3. Set auth.allow on sub dir d1 for client1 and d2 for client2.
4. Mount sub-dir d1 on client1 and d2 on client2.
5. Perform IO on mounts.
6. Reboot the node from which sub-dirs are
mounted and wait for node to come up.
7. Verify if peers are connected.
8. Check whether bricks are online.
9. Validate IO process.
"""
# Creating two sub directories on mounted volume
ret = mkdir(self.mounts[0].client_system,
"%s/d1" % self.mounts[0].mountpoint)
self.assertTrue(ret, ("Failed to create directory 'd1' in volume %s "
"from client %s" %
(self.volname, self.mounts[0].client_system)))
ret = mkdir(self.mounts[0].client_system,
"%s/d2" % self.mounts[0].mountpoint)
self.assertTrue(ret, ("Failed to create directory 'd2' in volume %s "
"from client %s" %
(self.volname, self.mounts[0].client_system)))
# Unmounting volumes
ret = self.unmount_volume(self.mounts)
self.assertTrue(ret, "Failed to unmount one or more volumes")
g.log.info("Successfully unmounted all volumes")
# Setting authentication for directories
auth_dict = {
'/d1': [self.mounts[0].client_system],
'/d2': [self.mounts[1].client_system]
}
ret = set_auth_allow(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set authentication")
g.log.info("Successfully set authentication on sub directories")
# Creating mounts list
self.subdir_mounts = [
copy.deepcopy(self.mounts[0]),
copy.deepcopy(self.mounts[1])
]
self.subdir_mounts[0].volname = "%s/d1" % self.volname
self.subdir_mounts[1].volname = "%s/d2" % self.volname
# Mounting sub directories to authenticated clients
for mount_obj in self.subdir_mounts:
ret = mount_obj.mount()
self.assertTrue(
ret, ("Failed to mount sub directory %s on client"
" %s" % (mount_obj.volname, mount_obj.client_system)))
g.log.info("Successfully mounted sub directory %s on client %s",
mount_obj.volname, mount_obj.client_system)
g.log.info("Successfully mounted sub directories to authenticated "
"clients")
# Start IO on all mounts.
all_mounts_procs = []
count = 1
for mount_obj in self.subdir_mounts:
g.log.info("Starting IO on %s:%s", mount_obj.client_system,
mount_obj.mountpoint)
cmd = ("/usr/bin/env python %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" %
(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
# Reboot node and wait for node to come up.
ret, _ = reboot_nodes_and_wait_to_come_online(self.mnode)
self.assertTrue(
ret, "Node reboot failed. Node %s has not came up" % self.mnode)
# Check whether peers are in connected state
ret = self.validate_peers_are_connected()
self.assertTrue(ret, "All nodes are not in connected state.")
# Get the bricks list of the volume
g.log.info("Fetching bricks list of the volume : %s", self.volname)
bricks_list = get_all_bricks(self.mnode, self.volname)
g.log.info("Brick List : %s", bricks_list)
# Check whether all bricks are online
g.log.info("Verifying whether all bricks are online.")
ret = are_bricks_online(self.mnode, self.volname, bricks_list)
self.assertTrue(ret, "All bricks are not online.")
g.log.info("All bricks are online.")
# Validate IO
g.log.info("Validating IO's")
ret = validate_io_procs(all_mounts_procs, self.subdir_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.")
ret = get_mounts_stat(self.subdir_mounts)
self.assertTrue(ret, "Stat failed on some of the clients")
g.log.info("Successfully got stat of all files/dirs created")
# Unmount sub-directories
ret = self.unmount_volume(self.subdir_mounts)
self.assertTrue(ret, "Failed to unmount one or more sub-directories")
g.log.info("Successfully unmounted all sub-directories")
def test_auth_allow_fqdn(self):
"""
Check sub dir auth.allow functionality using FQDN
Steps:
1. Create two sub directories on mounted volume
2. Unmount volume from clients
3. Set auth.allow on sub dir d1 for client1 and d2 for client2 using
fqdn
4. Mount d1 on client1 and d2 on client2. This should pass.
5. Try to mount d1 on client2 and d2 on client1. This should fail.
"""
# Creating sub directories on mounted volume
ret = mkdir(self.mounts[0].client_system,
"%s/d1" % self.mounts[0].mountpoint)
self.assertTrue(ret, ("Failed to create directory 'd1' in volume %s "
"from client %s" %
(self.volname, self.mounts[0].client_system)))
ret = mkdir(self.mounts[0].client_system,
"%s/d2" % self.mounts[0].mountpoint)
self.assertTrue(ret, ("Failed to create directory 'd2' in volume %s "
"from client %s" %
(self.volname, self.mounts[0].client_system)))
# Unmounting volumes
ret = self.unmount_volume(self.mounts)
self.assertTrue(ret, "Failed to unmount one or more volumes")
g.log.info("Successfully unmounted all volumes")
# Obtain hostname of clients
ret, hostname_client1, _ = g.run(self.mounts[0].client_system,
"hostname")
self.assertEqual(ret, 0, ("Failed to obtain hostname of client %s" %
self.mounts[0].client_system))
g.log.info("Obtained hostname of client. IP- %s, hostname- %s",
self.mounts[0].client_system, hostname_client1.strip())
ret, hostname_client2, _ = g.run(self.mounts[1].client_system,
"hostname")
self.assertEqual(ret, 0, ("Failed to obtain hostname of client %s" %
self.mounts[1].client_system))
g.log.info("Obtained hostname of client. IP- %s, hostname- %s",
self.mounts[1].client_system, hostname_client2.strip())
# Setting authentication
auth_dict = {
'/d1': [hostname_client1.strip()],
'/d2': [hostname_client2.strip()]
}
if not set_auth_allow(self.volname, self.mnode, auth_dict):
raise ExecutionError("Failed to set authentication")
g.log.info("Successfully set authentication on sub directories")
# Creating mounts list for authenticated clients
self.subdir_mounts = [
copy.deepcopy(self.mounts[0]),
copy.deepcopy(self.mounts[1])
]
self.subdir_mounts[0].volname = "%s/d1" % self.volname
self.subdir_mounts[1].volname = "%s/d2" % self.volname
# Mounting sub directories on authenticated clients
for mount_obj in self.subdir_mounts:
ret = mount_obj.mount()
self.assertTrue(
ret, ("Failed to mount sub directory %s on client"
" %s" % (mount_obj.volname, mount_obj.client_system)))
g.log.info("Successfully mounted sub directory %s on client %s",
mount_obj.volname, mount_obj.client_system)
g.log.info("Successfully mounted sub directories to authenticated "
"clients")
# Creating mounts list for unauthenticated clients
self.unauth_subdir_mounts = [
copy.deepcopy(self.mounts[0]),
copy.deepcopy(self.mounts[1])
]
self.unauth_subdir_mounts[0].volname = "%s/d2" % self.volname
self.unauth_subdir_mounts[1].volname = "%s/d1" % self.volname
self.unauth_subdir_mounts[0].mountpoint \
= "%s_unauth" % self.unauth_subdir_mounts[0].mountpoint
self.unauth_subdir_mounts[1].mountpoint \
= "%s_unauth" % self.unauth_subdir_mounts[1].mountpoint
# Trying to mount volume sub directories on unauthenticated clients
for mount_obj in self.unauth_subdir_mounts:
if mount_obj.mount():
g.log.warning(
"Mount command did not fail as expected. "
"sub-dir: %s, client: %s, mount point: %s",
mount_obj.volname, mount_obj.client_system,
mount_obj.mountpoint)
ret = mount_obj.is_mounted()
if ret:
self.subdir_mounts.append(mount_obj)
self.assertFalse(
ret, ("Mount operation did not fail as "
"expected. Mount operation of sub "
"directory %s on client %s passed."
"Mount point: %s" %
(mount_obj.volname, mount_obj.client_system,
mount_obj.mountpoint)))
g.log.info(
"Mount command passed. But sub directory "
"is not mounted. This is expected. "
"sub-dir: %s, client: %s, mount point: %s",
mount_obj.volname, mount_obj.client_system,
mount_obj.mountpoint)
g.log.info(
"Mount operation of sub directory %s on client %s "
"failed as expected.", mount_obj.volname,
mount_obj.client_system)
g.log.info("Verified mount operation of sub-dirs on "
"unauthenticated client. "
"Mount operation failed as expected.")
# Unmount sub-directories
ret = self.unmount_volume(self.subdir_mounts)
if not ret:
raise ExecutionError("Failed to unmount sub-directories.")
g.log.info("Successfully unmounted all sub-directories.")
def test_subdir_with_quotaobject(self):
# pylint: disable=too-many-statements
"""
Mount the volume
Create 1 subdir on mountpoint "d1"
unmount volume
Auth allow - Client1(d1),Client2(full volume)
Mount the subdir "d1" on client1 and volume on client2
Enable quota on volume
Set quota object limit on subdir "d1" and volume
subdir "d1" quota limit- 50
Volume quota limit - 200
Start writing 49 files on both subdir "d1" and volume
Fetch quota limit object list
Write 1 more file on subdir.This should fail
Again reset quota object limit to 75 now on subdir "d1"
Create 24 directories on subdir and volume.This should pass
Fetch quota limit object list
Create 1 more directory on subdir.This should fail
Create 1 more directory on volume.This should pass
"""
# Create directory d1 on mount point
ret = mkdir(self.mounts[0].client_system,
"%s/d1" % self.mounts[0].mountpoint)
self.assertTrue(
ret, ("Failed to create directory 'd1' on "
"volume %s from client %s" %
(self.mounts[0].volname, self.mounts[0].client_system)))
# unmount volume
ret = self.unmount_volume(self.mounts)
self.assertTrue(ret, "Volumes Unmount failed")
g.log.info("Volumes Unmounted successfully")
# Set authentication on the subdirectoy "d1" to access by client1
# and volume to access by client2
g.log.info(
'Setting authentication on subdirectory d1 to access '
'by client %s and on volume to access by client %s',
self.clients[0], self.clients[1])
ret = set_auth_allow(self.volname, self.mnode, {
'/d1': [self.clients[0]],
'/': [self.clients[1]]
})
self.assertTrue(
ret, 'Failed to set Authentication on volume %s' % self.volume)
# Creating mount list for mounting subdir mount and volume
self.subdir_mounts = [
copy.deepcopy(self.mounts[0]),
copy.deepcopy(self.mounts[1])
]
self.subdir_mounts[0].volname = "%s/d1" % self.volname
# Mount Subdirectory d1 on client 1 and volume on client 2
for mount_obj in self.subdir_mounts:
ret = mount_obj.mount()
self.assertTrue(
ret, ("Failed to mount %s on client"
" %s" % (mount_obj.volname, mount_obj.client_system)))
g.log.info("Successfully mounted %s on client %s",
mount_obj.volname, mount_obj.client_system)
g.log.info("Successfully mounted sub directory and volume to "
"authenticated clients")
# Enable quota on volume
g.log.info("Enabling quota on the volume %s", self.volname)
ret, _, _ = quota_enable(self.mnode, self.volname)
self.assertEqual(ret, 0, ("Failed to enable quota on the volume "
"%s", self.volname))
g.log.info("Successfully enabled quota on the volume %s", self.volname)
# Check if quota is enabled
g.log.info("Validate Quota is enabled on the volume %s", self.volname)
ret = is_quota_enabled(self.mnode, self.volname)
self.assertTrue(
ret, ("Quota is not enabled on the volume %s", self.volname))
g.log.info("Successfully Validated quota is enabled on volume %s",
self.volname)
# Set quota-soft-timeout to 0
g.log.info("Setting up soft timeout to 0")
ret, _, _ = quota_set_soft_timeout(self.mnode, self.volname, "0")
self.assertEqual(ret, 0, ("Failed to set quota-soft-timeout"))
g.log.info("Successfully set the quota-soft-timeout")
# Set quota-hard-timeout to 0
g.log.info("Setting up hard timeout with 0")
ret, _, _ = quota_set_hard_timeout(self.mnode, self.volname, "0")
self.assertEqual(ret, 0, ("Failed to set quota-hard-timeout"))
g.log.info("successfully set the quota-hard-timeout")
# Set Quota object limit on the subdir "d1" and on volume
for mount_obj in self.subdir_mounts:
if mount_obj.volname == "%s/d1" % self.volname:
path1 = "/d1"
limit = "50"
else:
path1 = "/"
limit = "200"
g.log.info("Set Quota Limit on the path %s of the volume %s",
path1, self.volname)
ret, _, _ = quota_limit_objects(self.mnode, self.volname, path1,
limit)
self.assertEqual(ret, 0,
("Failed to set quota limit on path "
"%s of the volume %s", path1, self.volname))
g.log.info(
"Successfully set the quota limit on %s of the volume "
"%s", path1, self.volname)
# Create near to 49 files on both subdir mount and volume mount
for mount_object in self.subdir_mounts:
g.log.info("Creating Files on %s:%s", mount_object.client_system,
mount_object.mountpoint)
cmd = ("cd %s ; for i in `seq 1 49` ;"
"do touch $i;done " % (mount_object.mountpoint))
ret, _, _ = g.run(mount_object.client_system, cmd)
self.assertEqual(ret, 0, "Failed to create files on mountpoint")
g.log.info("Files created successfully on mountpoint")
# Fetch Quota List object on the volume
g.log.info("Get Quota list on the volume %s", self.volname)
quota_list = quota_fetch_list_objects(self.mnode, self.volname)
self.assertIsNotNone(quota_list, ("Failed to get the quota list "
"of the volume %s", self.volname))
# Create 1 file on subdir to check if quota limit is
# adhere by subdir d1
g.log.info("Creating File on %s:%s", self.clients[0],
self.subdir_mounts[0].mountpoint)
cmd = ("cd %s ; touch test " % (self.subdir_mounts[0].mountpoint))
ret, _, _ = g.run(self.clients[0], cmd)
self.assertNotEqual(ret, 0, ("File creation was expected to Fail."
"But it got passed"))
g.log.info(
"File creation failed as expected on %s:%s as quota"
" limit reached already", self.clients[0],
self.subdir_mounts[0].mountpoint)
# Modify quota object limit for subdir from 50 to 75
path1 = "/d1"
g.log.info("Set Quota Limit on the path %s of the volume %s", path1,
self.volname)
ret, _, _ = quota_limit_objects(self.mnode, self.volname, path1, "75")
self.assertEqual(ret, 0, ("Failed to set quota limit on path %s of "
" the volume %s", path1, self.volname))
g.log.info(
"Successfully set the quota limit on %s of the volume "
"%s", path1, self.volname)
# Create near to 25 directories on both subdir mount "d1" and volume
for mount_object in self.subdir_mounts:
g.log.info("Creating directories on %s:%s",
mount_object.client_system, mount_object.mountpoint)
for i in range(0, 25):
ret = mkdir(mount_object.client_system,
"%s/dir%s" % (mount_object.mountpoint, i),
parents=True)
self.assertTrue(ret, "Failed to create directories"
"on mountpoint")
g.log.info("Directories created successfully on mountpoint")
# Get Quota List on the volume
g.log.info("Get Quota list on the volume %s", self.volname)
quota_list = quota_fetch_list_objects(self.mnode, self.volname)
self.assertIsNotNone(quota_list, ("Failed to get the quota list "
"of the volume %s", self.volname))
# Create 1 directory on subdir "d1" and volume to check if quota
# limit is adhere by subdir d1 and volume
for mount_object in self.subdir_mounts:
g.log.info("Creating directory on %s:%s",
mount_object.client_system, mount_object.mountpoint)
ret = mkdir(mount_object.client_system,
"%s/dirTest" % mount_object.mountpoint,
parents=True)
if mount_object.volname == "%s/d1" % self.volname:
self.assertFalse(
ret, "Directory creation was expected"
"to Fail.But it got passed")
g.log.info("Direction creation failed as expected on"
"subdir d1")
else:
self.assertTrue(ret, "Directory creation got failed"
"on volume")
g.log.info("Direction creation successful on volume")
def test_subdir_with_replacebrick(self):
# pylint: disable=too-many-statements
"""
Mount the volume
Create 50 directories on mount point
Unmount volume
Auth allow - Client1(subdir25),Client2(subdir15)
Mount the subdir to their authorized respective clients
Start IO's on both subdirs
Perform replace-brick
Validate on client if subdir's are mounted post replace-brick
operation is performed
Stat data on subdirs
"""
# Create directories on mount point
for i in range(0, 50):
ret = mkdir(self.mounts[0].client_system,
"%s/subdir%s" % (self.mounts[0].mountpoint, i))
self.assertTrue(
ret,
("Failed to create directory %s/subdir%s on"
"volume from client %s" %
(self.mounts[0].mountpoint, i, self.mounts[0].client_system)))
g.log.info("Successfully created directories on mount point")
# unmount volume
ret = self.unmount_volume(self.mounts)
self.assertTrue(ret, "Volumes Unmount failed")
g.log.info("Volumes Unmounted successfully")
# Set authentication on the subdirectory subdir25 to access by
# client1 and subdir15 to access by 2 clients
g.log.info(
'Setting authentication on subdir25 and subdir15'
'for client %s and %s', self.clients[0], self.clients[1])
ret = set_auth_allow(
self.volname, self.mnode, {
'/subdir25': [self.mounts[0].client_system],
'/subdir15': [self.mounts[1].client_system]
})
self.assertTrue(
ret, 'Failed to set Authentication on volume %s' % self.volume)
# Creating mount list for mounting selected subdirs on authorized
# clients
self.subdir_mounts = [
copy.deepcopy(self.mounts[0]),
copy.deepcopy(self.mounts[1])
]
self.subdir_mounts[0].volname = "%s/subdir25" % self.volname
self.subdir_mounts[1].volname = "%s/subdir15" % self.volname
# Mount Subdirectory subdir25 on client 1 and subdir15 on client 2
for mount_obj in self.subdir_mounts:
ret = mount_obj.mount()
self.assertTrue(
ret, ("Failed to mount %s on client"
" %s" % (mount_obj.volname, mount_obj.client_system)))
g.log.info("Successfully mounted %s on client %s",
mount_obj.volname, mount_obj.client_system)
g.log.info("Successfully mounted sub directories on"
"authenticated clients")
# Start IO on all the subdir mounts.
all_mounts_procs = []
count = 1
for mount_obj in self.subdir_mounts:
g.log.info("Starting IO on %s:%s", mount_obj.client_system,
mount_obj.mountpoint)
cmd = ("/usr/bin/env python %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" %
(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
# Get stat of all the files/dirs created.
g.log.info("Get stat of all the files/dirs created.")
ret = get_mounts_stat(self.subdir_mounts)
self.assertTrue(ret, "Stat failed on some of the clients")
g.log.info("Successfully got stat of all files/dirs created")
# Log Volume Info and Status before replacing brick from the volume.
g.log.info(
"Logging volume info and Status before replacing brick "
"from the volume %s", self.volname)
ret = log_volume_info_and_status(self.mnode, self.volname)
self.assertTrue(ret, ("Logging volume info and status failed on "
"volume %s", self.volname))
g.log.info("Successful in logging volume info and status of volume %s",
self.volname)
# Replace brick from a sub-volume
g.log.info("Replace a brick from the volume")
ret = replace_brick_from_volume(self.mnode, self.volname, self.servers,
self.all_servers_info)
self.assertTrue(ret, "Failed to replace brick from the volume")
g.log.info("Successfully replaced brick from the volume")
# Wait for volume processes to be online
g.log.info("Wait for volume processes to be online")
ret = wait_for_volume_process_to_be_online(self.mnode, self.volname)
self.assertTrue(ret, ("All volume %s processes failed to come up "
"online", self.volname))
g.log.info("All volume %s processes came up "
"online successfully", self.volname)
# Log Volume Info and Status after replacing the brick
g.log.info(
"Logging volume info and Status after replacing brick "
"from the volume %s", self.volname)
ret = log_volume_info_and_status(self.mnode, self.volname)
self.assertTrue(ret, ("Failed Logging volume info and status on "
"volume %s", self.volname))
g.log.info("Successful in logging volume info and status of volume %s",
self.volname)
# Wait for self-heal to complete
g.log.info("Wait for self-heal to complete")
ret = monitor_heal_completion(self.mnode, self.volname)
self.assertTrue(ret, 'Heal has not yet completed')
g.log.info("self-heal is successful after replace-brick operation")
# Again validate if subdirectories are still mounted post replace-brick
for mount_obj in self.subdir_mounts:
ret = mount_obj.is_mounted()
self.assertTrue(
ret, ("Subdirectory %s is not mounted on client"
" %s" % (mount_obj.volname, mount_obj.client_system)))
g.log.info("Subdirectory %s is mounted on client %s",
mount_obj.volname, mount_obj.client_system)
g.log.info("Successfully validated that subdirectories are mounted"
"on client1 and clients 2 post replace-brick operation")
# Validate IO
g.log.info("Validating IO's")
ret = validate_io_procs(all_mounts_procs, self.subdir_mounts)
self.assertTrue(ret, "IO failed on some of the clients")
g.log.info("Successfully validated all io's")
def test_auth_reject_allow_same_client(self):
"""
Verify auth.reject and auth.allow volume options in volume level using
both client ip and hostname.
Steps:
1. Create and start volume.
2. Set auth.reject on volume for client1 using ip of client1.
3. Set auth.allow on volume for client1 using ip of client1.
4. Try to mount volume on client1. This should fail.
5. Check the client1 log for AUTH_FAILED event.
6. Mount volume on client2.This should fail.
7. Check the client2 log for AUTH_FAILED event.
8. Set auth.reject on volume for client1 using hostname of client1.
9. Set auth.allow on volume for client1 using hostname of client1.
10. Repeat steps 4 to 7
"""
# pylint: disable = too-many-statements
# Setting auth.reject on volume for client1 using ip
auth_dict = {'all': [self.mounts[0].client_system]}
ret = set_auth_reject(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set auth.reject volume option.")
# Setting auth.allow on volume for client1 using ip
auth_dict = {'all': [self.mounts[0].client_system]}
ret = set_auth_allow(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set auth.allow volume option")
# Trying to mount volume on client1
self.unauthenticated_mount(self.mounts[0])
# Verify whether mount failure on client1 is due to auth error
log_msg = self.is_auth_failure(self.mounts[0].client_system)
prev_log_statement = log_msg
# Mounting volume on client2
self.unauthenticated_mount(self.mounts[1])
g.log.info("Verification of auth.reject and auth.allow options on "
"volume using client IP is successful")
# Obtain hostname of client1
ret, hostname_client1, _ = g.run(self.mounts[0].client_system,
"hostname")
self.assertEqual(ret, 0, ("Failed to obtain hostname of client %s" %
self.mounts[0].client_system))
g.log.info("Obtained hostname of client. IP- %s, hostname- %s",
self.mounts[0].client_system, hostname_client1.strip())
# Obtain hostname of client2
ret, hostname_client2, _ = g.run(self.mounts[1].client_system,
"hostname")
self.assertEqual(ret, 0, ("Failed to obtain hostname of client %s" %
self.mounts[1].client_system))
g.log.info("Obtained hostname of client. IP- %s, hostname- %s",
self.mounts[1].client_system, hostname_client2.strip())
# Setting auth.reject on volume for client1 using hostname
auth_dict = {'all': [hostname_client1.strip()]}
ret = set_auth_reject(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set auth.reject volume option.")
# Setting auth.allow on volume for client1 using hostname
auth_dict = {'all': [hostname_client1.strip()]}
ret = set_auth_allow(self.volname, self.mnode, auth_dict)
self.assertTrue(ret, "Failed to set auth.allow volume option")
# Trying to mount volume on client1
self.unauthenticated_mount(self.mounts[0])
# Verify whether mount failure on client1 is due to auth error
log_msg = self.is_auth_failure(self.mounts[0].client_system,
prev_log_statement)
prev_log_statement = log_msg
# Mounting volume on client2
self.unauthenticated_mount(self.mounts[1])
# Verify whether mount failure on client2 is due to auth error
log_msg = self.is_auth_failure(self.mounts[1].client_system)
prev_log_statement = log_msg
