def test_exec(config):
add_io_info = AddIOInfo()
add_io_info.initialize()
test_info = AddTestInfo('create m buckets, n keys and download')
try:
# test case starts
test_info.started_info()
with open('user_details') as fout:
all_user_details = simplejson.load(fout)
for each_user in all_user_details:
rgw = ObjectOps(config, each_user)
buckets = rgw.create_bucket()
rgw.upload(buckets)
rgw.download_keys()
test_info.success_status('test completed')
sys.exit(0)
except AssertionError as e:
log.error(e)
test_info.failed_status('test failed: %s' % e)
sys.exit(1)
def test_exec(config):
test_info = AddTestInfo(
'enable versioning on a bucket and upload keys and its versions')
add_io_info = AddIOInfo()
add_io_info.initialize()
try:
test_info.started_info()
all_user_details = rgw_lib.create_users(config.user_count)
for each_user in all_user_details:
rgw = ObjectOps(config, each_user)
rgw.enable_versioning = True
rgw.version_count = config.version_count
buckets = rgw.create_bucket()
rgw.set_bucket_properties()
rgw.upload(buckets)
test_info.success_status('test completed')
sys.exit(0)
except AssertionError, e:
log.error(e)
sys.exit(1)
def test_exec(config):
test_info = AddTestInfo('multipart Upload')
add_io_info = AddIOInfo()
add_io_info.initialize()
try:
# test case starts
test_info.started_info()
all_user_details = rgw_lib.create_users(config.user_count)
log.info('multipart upload enabled')
for each_user in all_user_details:
config.objects_count = 1
rgw = ObjectOps(config, each_user)
buckets = rgw.create_bucket()
rgw.multipart_upload(buckets)
test_info.success_status('test completed')
sys.exit(0)
except AssertionError, e:
log.error(e)
test_info.failed_status('test failed: %s' % e)
sys.exit(1)
def test_exec(config):
test_info = AddTestInfo("create users")
add_io_info = AddIOInfo()
add_io_info.initialize()
try:
test_info.started_info()
all_user_details = rgw_lib.create_users(config.user_count,
config.cluster_name)
# dump the list of users into a file
with open("user_details", "w") as fout:
json.dump(all_user_details, fout)
test_info.success_status("user creation completed")
sys.exit(0)
except AssertionError as e:
log.error(e)
test_info.failed_status("user creation failed: %s" % e)
sys.exit(1)
def test_exec_read(config):
grants = {'permission': 'READ', 'user_id': None, 'recursive': True}
test_info = AddTestInfo(
'Test with read permission on buckets for all users')
add_io_info = AddIOInfo()
add_io_info.initialize()
try:
# test case starts
test_info.started_info()
all_user_details = rgw_lib.create_users(config.user_count)
user1 = all_user_details[0]
log.info('user1: %s' % user1)
all_user_details.pop(0)
u1 = ObjectOps(config, user1)
for each_user in all_user_details:
u2 = ObjectOps(config, each_user)
u2_canonical_id = u2.canonical_id
log.info('canonical id of u2: %s' % u2_canonical_id)
grants['user_id'] = u2_canonical_id
u1.grants = None
u1.create_bucket()
u1.set_bucket_properties()
u2.bucket_names = u1.bucket_names
u2.buckets_created = u1.buckets_created
u2.grants = None
u2.set_bucket_properties()
# set permissions and read
u1.grants = grants
u1.set_bucket_properties()
u2.bucket_names = u1.bucket_names
u2.buckets_created = u1.buckets_created
u2.grants = None
u2.set_bucket_properties()
test_info.success_status('test completed')
except AssertionError, e:
log.error(e)
test_info.failed_status('test failed: %s' % e)
sys.exit(1)
def test_exec(config):
test_info = AddTestInfo('create m buckets')
add_io_info = AddIOInfo()
add_io_info.initialize()
try:
# test case starts
test_info.started_info()
all_user_details = rgw_lib.create_users(config.user_count)
for each_user in all_user_details:
rgw = ObjectOps(config, each_user)
assert rgw.create_bucket()
test_info.success_status('test completed')
sys.exit(0)
except AssertionError, e:
log.error(e)
test_info.failed_status('test failed: %s' % e)
sys.exit(1)
def test_exec(config):
test_info = AddTestInfo("multipart Upload with cancel and download")
add_io_info = AddIOInfo()
add_io_info.initialize()
try:
# test case starts
test_info.started_info()
all_user_details = rgw_lib.create_users(config.user_count)
log.info("multipart upload enabled")
for each_user in all_user_details:
config.objects_count = 1
rgw = ObjectOps(config, each_user)
buckets = rgw.create_bucket()
rgw.break_upload_at_part_no = config.break_at_part_no
rgw.multipart_upload(buckets)
log.info("starting at part no: %s" % config.break_at_part_no)
log.info("--------------------------------------------------")
rgw.break_upload_at_part_no = 0
rgw.multipart_upload(buckets)
rgw.download_keys()
test_info.success_status("test completed")
sys.exit(0)
except AssertionError as e:
log.error(e)
test_info.failed_status("test failed: %s" % e)
sys.exit(1)
def test_exec(config):
test_info = AddTestInfo('create m buckets, n objects and delete')
try:
test_info.started_info()
add_io_info = AddIOInfo()
read_io_info = ReadIOInfo()
add_io_info.initialize()
rgw_service = RGWService()
quota_mgmt = QuotaMgmt()
test_config = AddToCephConf()
if config.shards:
test_config.set_to_ceph_conf(
'global', ConfigOpts.rgw_override_bucket_index_max_shards,
config.shards)
rgw_service.restart()
no_of_shards_for_each_bucket = int(config.shards) * int(
config.bucket_count)
with open('user_details') as fout:
all_user_details = simplejson.load(fout)
for each_user in all_user_details:
add_io_info.add_user_info(
**{
'user_id': each_user['user_id'],
'access_key': each_user['access_key'],
'secret_key': each_user['secret_key']
})
for each_user in all_user_details:
if config.max_objects:
quota_mgmt.set_bucket_quota(each_user['user_id'],
config.max_objects)
quota_mgmt.enable_bucket_quota(each_user['user_id'])
rgw = ObjectOps(config, each_user)
buckets = rgw.create_bucket()
rgw.upload(buckets)
#read_io_info.verify_io()
test_info.success_status('test completed')
sys.exit(0)
except AssertionError, e:
log.error(e)
test_info.failed_status('test failed: %s' % e)
sys.exit(1)
def test_exec_read(config):
test_info = AddTestInfo('Test with read permission on buckets')
try:
# test case starts
add_io_info = AddIOInfo()
add_io_info.initialize()
test_info.started_info()
all_user_details = rgw_lib.create_users(config.user_count)
user1 = all_user_details[0]
log.info('user1: %s' % user1)
user2 = all_user_details[1]
log.info('user2: %s' % user2)
u1 = ObjectOps(config, user1)
u2 = ObjectOps(config, user2)
u1_grants = {
'permission': 'READ',
'user_id': u2.canonical_id,
'recursive': True
}
u2_grants = {
'permission': 'FULL_CONTROL',
'user_id': u1.canonical_id,
'recursive': True
}
u1.grants = u1_grants
u1.create_bucket()
u1_buckets = u1.set_bucket_properties()
u1.upload(u1_buckets, object_base_name=u1.canonical_id + '.key')
all_keys = u1_buckets[0].get_all_keys()
for key in all_keys:
log.info('all keys from user 1--------------')
log.info('name: %s' % key.name)
u2.grants = u2_grants
u2.create_bucket()
u2_buckets = u2.set_bucket_properties()
bu2 = u1.connection['conn'].get_bucket(u2_buckets[0].name)
log.info('copying the objects from u1 to u2')
for each in all_keys:
bu2.copy_key(each.key, u1_buckets[0].name, each.key)
all_keys2 = bu2.get_all_keys()
for key in all_keys2:
log.info('all keys from user 2--------------')
log.info('name: %s' % key.name)
log.info('verifying copied objects--------')
u2.grants = None
u2_buckets = u2.set_bucket_properties()
all_keys3 = u2_buckets[0].get_all_keys()
for key in all_keys3:
log.info('all keys from user 2--------------')
log.info('name: %s' % key.name)
test_info.success_status('test completed')
except AssertionError as e:
log.error(e)
test_info.failed_status('test failed: %s' % e)
sys.exit(1)
def test_exec_read(config):
test_info = AddTestInfo("Test with read permission on buckets")
try:
# test case starts
add_io_info = AddIOInfo()
add_io_info.initialize()
test_info.started_info()
all_user_details = rgw_lib.create_users(config.user_count)
user1 = all_user_details[0]
log.info("user1: %s" % user1)
user2 = all_user_details[1]
log.info("user2: %s" % user2)
u1 = ObjectOps(config, user1)
u2 = ObjectOps(config, user2)
u1_grants = {
"permission": "READ",
"user_id": u2.canonical_id,
"recursive": True,
}
u2_grants = {
"permission": "FULL_CONTROL",
"user_id": u1.canonical_id,
"recursive": True,
}
u1.grants = u1_grants
u1.create_bucket()
u1_buckets = u1.set_bucket_properties()
u1.upload(u1_buckets, object_base_name=u1.canonical_id + ".key")
all_keys = u1_buckets[0].get_all_keys()
for key in all_keys:
log.info("all keys from user 1--------------")
log.info("name: %s" % key.name)
u2.grants = u2_grants
u2.create_bucket()
u2_buckets = u2.set_bucket_properties()
bu2 = u1.connection["conn"].get_bucket(u2_buckets[0].name)
log.info("copying the objects from u1 to u2")
for each in all_keys:
bu2.copy_key(each.key, u1_buckets[0].name, each.key)
all_keys2 = bu2.get_all_keys()
for key in all_keys2:
log.info("all keys from user 2--------------")
log.info("name: %s" % key.name)
log.info("verifying copied objects--------")
u2.grants = None
u2_buckets = u2.set_bucket_properties()
all_keys3 = u2_buckets[0].get_all_keys()
for key in all_keys3:
log.info("all keys from user 2--------------")
log.info("name: %s" % key.name)
test_info.success_status("test completed")
except AssertionError as e:
log.error(e)
test_info.failed_status("test failed: %s" % e)
sys.exit(1)
def test_exec(config):
add_io_info = AddIOInfo()
add_io_info.initialize()
test_info = AddTestInfo("multipart Upload with cancel and download")
try:
# test case starts
test_info.started_info()
with open("user_details") as fout:
all_user_details = simplejson.load(fout)
for each_user in all_user_details:
add_io_info.add_user_info(
**{
"user_id": each_user["user_id"],
"access_key": each_user["access_key"],
"secret_key": each_user["secret_key"],
})
log.info("multipart upload enabled")
for each_user in all_user_details:
config.objects_count = 2
rgw = ObjectOps(config, each_user)
buckets = rgw.create_bucket()
rgw.break_upload_at_part_no = config.break_at_part_no
rgw.multipart_upload(buckets)
log.info("starting at part no: %s" % config.break_at_part_no)
log.info("--------------------------------------------------")
rgw.break_upload_at_part_no = 0
rgw.multipart_upload(buckets)
rgw.download_keys()
test_info.success_status("test completed")
sys.exit(0)
except AssertionError as e:
log.error(e)
test_info.failed_status("test failed: %s" % e)
sys.exit(1)
def test_exec(config):
test_info = AddTestInfo("create m buckets, n objects and delete")
add_io_info = AddIOInfo()
add_io_info.initialize()
try:
test_info.started_info()
rgw_service = RGWService()
quota_mgmt = QuotaMgmt()
test_config = AddToCephConf()
if config.shards:
test_config.set_to_ceph_conf(
"global", ConfigOpts.rgw_override_bucket_index_max_shards,
config.shards)
log.info(
"test to continue after service restart, sleept time 120 seconds"
)
no_of_shards_for_each_bucket = int(config.shards) * int(
config.bucket_count)
if config.dynamic_sharding is True:
test_config.set_to_ceph_conf(
"global",
ConfigOpts.rgw_max_objs_per_shard,
config.max_objects_per_shard,
)
test_config.set_to_ceph_conf("global",
ConfigOpts.rgw_dynamic_resharding,
True)
num_shards_expected = config.objects_count / config.max_objects_per_shard
log.info("num_shards_expected: %s" % num_shards_expected)
log.info(
"test to continue after service restart, sleept time 120 seconds"
)
rgw_service.restart()
time.sleep(120)
all_user_details = rgw_lib.create_users(config.user_count)
for each_user in all_user_details:
if config.max_objects:
quota_mgmt.set_bucket_quota(each_user["user_id"],
config.max_objects)
quota_mgmt.enable_bucket_quota(each_user["user_id"])
rgw = ObjectOps(config, each_user)
buckets = rgw.create_bucket()
rgw.upload(buckets)
test_info.success_status("test completed")
sys.exit(0)
except AssertionError as e:
log.error(e)
test_info.failed_status("test failed: %s" % e)
sys.exit(1)
def test_exec(config):
add_io_info = AddIOInfo()
add_io_info.initialize()
test_info = AddTestInfo('multipart Upload with cancel and download')
try:
# test case starts
test_info.started_info()
with open('user_details') as fout:
all_user_details = simplejson.load(fout)
for each_user in all_user_details:
add_io_info.add_user_info(**{'user_id': each_user['user_id'],
'access_key': each_user['access_key'],
'secret_key': each_user['secret_key']})
log.info('multipart upload enabled')
for each_user in all_user_details:
config.objects_count = 2
rgw = ObjectOps(config, each_user)
buckets = rgw.create_bucket()
rgw.break_upload_at_part_no = config.break_at_part_no
rgw.multipart_upload(buckets)
log.info('starting at part no: %s' % config.break_at_part_no)
log.info('--------------------------------------------------')
rgw.break_upload_at_part_no = 0
rgw.multipart_upload(buckets)
rgw.download_keys()
test_info.success_status('test completed')
sys.exit(0)
except AssertionError as e:
log.error(e)
test_info.failed_status('test failed: %s' % e)
sys.exit(1)
def test_exec(config):
add_io_info = AddIOInfo()
add_io_info.initialize()
test_info = AddTestInfo("create m buckets, n objects and delete")
try:
# test case starts
test_info.started_info()
with open("user_details") as fout:
all_user_details = simplejson.load(fout)
for each_user in all_user_details:
add_io_info.add_user_info(
**{
"user_id": each_user["user_id"],
"access_key": each_user["access_key"],
"secret_key": each_user["secret_key"],
}
)
for each_user in all_user_details:
rgw = ObjectOps(config, each_user)
rgw.bucket_ops.test_op_code = "delete"
buckets = rgw.create_bucket()
rgw.upload(buckets, test_op_code="delete")
rgw.delete_keys()
time.sleep(15)
rgw.delete_bucket()
test_info.success_status("test completed")
sys.exit(0)
except AssertionError as e:
log.error(e)
test_info.failed_status("test failed: %s" % e)
sys.exit(1)
def test_exec(config):
add_io_info = AddIOInfo()
add_io_info.initialize()
test_info = AddTestInfo(
"enable versioning on a bucket and upload keys and its versions "
"and suspend version on the same bucket"
)
try:
test_info.started_info()
with open("user_details") as fout:
all_user_details = simplejson.load(fout)
for each_user in all_user_details:
add_io_info.add_user_info(
**{
"user_id": each_user["user_id"],
"access_key": each_user["access_key"],
"secret_key": each_user["secret_key"],
}
)
for each_user in all_user_details:
rgw = ObjectOps(config, each_user)
rgw.enable_versioning = True
rgw.version_count = config.version_count
buckets = rgw.create_bucket()
rgw.set_bucket_properties()
rgw.upload(buckets)
rgw.enable_versioning = False
rgw.set_bucket_properties()
test_info.success_status("test completed")
sys.exit(0)
except AssertionError as e:
log.error(e)
sys.exit(1)
def test_exec(config):
add_io_info = AddIOInfo()
add_io_info.initialize()
test_info = AddTestInfo('create m buckets, n objects and delete')
try:
# test case starts
test_info.started_info()
with open('user_details') as fout:
all_user_details = simplejson.load(fout)
for each_user in all_user_details:
add_io_info.add_user_info(
**{
'user_id': each_user['user_id'],
'access_key': each_user['access_key'],
'secret_key': each_user['secret_key']
})
for each_user in all_user_details:
rgw = ObjectOps(config, each_user)
rgw.bucket_ops.test_op_code = 'delete'
buckets = rgw.create_bucket()
rgw.upload(buckets, test_op_code='delete')
rgw.delete_keys()
time.sleep(15)
rgw.delete_bucket()
test_info.success_status('test completed')
sys.exit(0)
except AssertionError, e:
log.error(e)
test_info.failed_status('test failed: %s' % e)
sys.exit(1)
def test_exec(config):
add_io_info = AddIOInfo()
add_io_info.initialize()
read_io_info = ReadIOInfo()
test_info = AddTestInfo("create m buckets")
try:
# test case starts
test_info.started_info()
with open("user_details") as fout:
all_user_details = simplejson.load(fout)
# write all users details to yaml file.
for each_user in all_user_details:
add_io_info.add_user_info(
**{
"user_id": each_user["user_id"],
"access_key": each_user["access_key"],
"secret_key": each_user["secret_key"],
})
for each_user in all_user_details:
log.info("User credentials: %s" % each_user)
rgw = ObjectOps(config, each_user)
assert rgw.create_bucket()
# read_io_info.verify_io()
test_info.success_status("test completed")
sys.exit(0)
except AssertionError as e:
log.error(e)
test_info.failed_status("test failed: %s" % e)
sys.exit(1)
def test_exec(config):
add_io_info = AddIOInfo()
add_io_info.initialize()
read_io_info = ReadIOInfo()
test_info = AddTestInfo('create m buckets')
try:
# test case starts
test_info.started_info()
with open('user_details') as fout:
all_user_details = simplejson.load(fout)
# write all users details to yaml file.
for each_user in all_user_details:
add_io_info.add_user_info(
**{
'user_id': each_user['user_id'],
'access_key': each_user['access_key'],
'secret_key': each_user['secret_key']
})
for each_user in all_user_details:
log.info('User credentials: %s' % each_user)
rgw = ObjectOps(config, each_user)
assert rgw.create_bucket()
#read_io_info.verify_io()
test_info.success_status('test completed')
sys.exit(0)
except AssertionError, e:
log.error(e)
test_info.failed_status('test failed: %s' % e)
sys.exit(1)
def test_exec(config):
add_io_info = AddIOInfo()
add_io_info.initialize()
read_io = ReadIOInfo()
test_info = AddTestInfo('multipart Upload')
try:
# test case starts
test_info.started_info()
with open('user_details') as fout:
all_user_details = simplejson.load(fout)
log.info('multipart upload enabled')
for each_user in all_user_details:
add_io_info.add_user_info(
**{
'user_id': each_user['user_id'],
'access_key': each_user['access_key'],
'secret_key': each_user['secret_key']
})
for each_user in all_user_details:
config.objects_count = 1
rgw = ObjectOps(config, each_user)
buckets = rgw.create_bucket()
rgw.multipart_upload(buckets)
test_info.success_status('test completed')
sys.exit(0)
except AssertionError, e:
log.error(e)
test_info.failed_status('test failed: %s' % e)
sys.exit(1)
def test_exec(config):
test_info = AddTestInfo("create m buckets, n keys and download")
add_io_info = AddIOInfo()
add_io_info.initialize()
try:
# test case starts
test_info.started_info()
all_user_details = rgw_lib.create_users(config.user_count)
for each_user in all_user_details:
rgw = ObjectOps(config, each_user)
buckets = rgw.create_bucket()
rgw.upload(buckets)
rgw.download_keys()
test_info.success_status("test completed")
sys.exit(0)
except AssertionError as e:
log.error(e)
test_info.failed_status("test failed: %s" % e)
sys.exit(1)
def test_exec_read(config):
"""
config.bucket_count = 3
config.objects_count = 3
config.objects_size_range = {'min': 50, 'max': 100}
"""
grants = {"permission": "READ", "user_id": None, "recursive": True}
test_info = AddTestInfo("Test with read permission on buckets")
add_io_info = AddIOInfo()
add_io_info.initialize()
try:
# test case starts
test_info.started_info()
all_user_details = rgw_lib.create_users(config.user_count)
user1 = all_user_details[0]
log.info("user1: %s" % user1)
user2 = all_user_details[1]
log.info("user2: %s" % user2)
u1 = ObjectOps(config, user1)
u2 = ObjectOps(config, user2)
u2_canonical_id = u2.canonical_id
log.info("canonical id of u2: %s" % u2_canonical_id)
grants["user_id"] = u2_canonical_id
u1.grants = None
u1.create_bucket()
u1.set_bucket_properties()
u2.bucket_names = u1.bucket_names
u2.buckets_created = u1.buckets_created
u2.grants = None
u2.set_bucket_properties()
# set permissions and read
u1.grants = grants
u1.set_bucket_properties()
u2.bucket_names = u1.bucket_names
u2.buckets_created = u1.buckets_created
u2.grants = None
u2.set_bucket_properties()
test_info.success_status("test completed")
except AssertionError as e:
log.error(e)
test_info.failed_status("test failed: %s" % e)
sys.exit(1)
def test_exec(config):
add_io_info = AddIOInfo()
add_io_info.initialize()
test_info = AddTestInfo('enable versioning on a bucket and upload '
'keys and its versions and delete its versions')
try:
test_info.started_info()
with open('user_details') as fout:
all_user_details = simplejson.load(fout)
for each_user in all_user_details:
add_io_info.add_user_info(
**{
'user_id': each_user['user_id'],
'access_key': each_user['access_key'],
'secret_key': each_user['secret_key']
})
for each_user in all_user_details:
rgw = ObjectOps(config, each_user)
rgw.enable_versioning = True
rgw.version_count = config.version_count
buckets = rgw.create_bucket()
rgw.set_bucket_properties()
rgw.upload(buckets)
rgw.delete_key_version()
test_info.success_status('test completed')
sys.exit(0)
except AssertionError, e:
log.error(e)
test_info.failed_status('test failed: %s' % e)
sys.exit(1)
def test_exec_write(config):
add_io_info = AddIOInfo()
add_io_info.initialize()
test_info = AddTestInfo(
"give the permission for all the users and then reset it")
try:
# test case starts
test_info.started_info()
with open("user_details") as fout:
all_user_details = simplejson.load(fout)
for each_user in all_user_details:
add_io_info.add_user_info(
**{
"user_id": each_user["user_id"],
"access_key": each_user["access_key"],
"secret_key": each_user["secret_key"],
})
user1 = all_user_details[0]
u1 = ObjectOps(config, user1)
log.info("user1: %s" % user1)
all_user_details.pop(0)
for each_user in all_user_details:
print("iter ------------------>")
log.info("user2: %s" % each_user)
u2 = ObjectOps(config, each_user)
u2_canonical_id = u2.canonical_id
log.info("canonical id of u2: %s" % u2_canonical_id)
log.info("setting only read permission")
grants = {"permission": "READ", "user_id": None, "recursive": True}
log.info("write persmission are not set")
grants["user_id"] = u2_canonical_id
u1.grants = grants
u1.create_bucket()
u1.set_bucket_properties()
u2.bucket_names = u1.bucket_names
u2.buckets_created = u1.buckets_created
u2.json_file_upload = u1.json_file_upload
u2.json_file_download = u1.json_file_download
u2.grants = None
u2.create_bucket()
buckets = u2.set_bucket_properties()
key_created = u2.upload(buckets)
if not key_created:
log.info(
"no write permission set and hence failing to create object"
)
elif key_created:
raise AssertionError("object created even with no permission")
log.info("setting permission to write also")
grants = {
"permission": "WRITE",
"user_id": u2_canonical_id,
"recursive": True,
}
u1.grants = grants
u1.set_bucket_properties()
u2.bucket_names = u1.bucket_names
u2.buckets_created = u1.buckets_created
u2.grants = None
buckets = u2.set_bucket_properties()
key_created = u2.upload(buckets,
object_base_name=str(u2.canonical_id) +
".key")
if key_created:
log.info("object created after permission set")
log.info(
"***************** removing grants and making the bucket private *****************"
)
u1.grants = None
u1.acls = "private"
u1.set_bucket_properties()
for each_user in all_user_details:
u2 = ObjectOps(config, each_user)
print("iter ------------------>")
u2.bucket_names = u1.bucket_names
u2.buckets_created = u1.buckets_created
u2.json_file_upload = u1.json_file_upload
u2.json_file_download = u1.json_file_download
u2.grants = None
buckets = u2.set_bucket_properties()
if not buckets:
log.info("bucket init failed: %s" % buckets)
elif buckets:
key_created = u2.upload(buckets)
if not key_created:
log.info(
"no write permission set and hence failing to create object"
)
elif key_created:
raise AssertionError(
"object created even with no permission")
test_info.success_status("test completed")
except AssertionError as e:
log.error(e)
test_info.failed_status("test failed: %s" % e)
sys.exit(1)
def test(yaml_file_path):
ganesha_test_config = {
"mount_point": "ganesha-mount",
"rgw_user_info": yaml_file_path,
}
log.info("ganesha_test_config :%s\n" % ganesha_test_config)
io_config = {
"base_dir_count": 2,
"sub_dir_count": 2,
"Files": {
"files_in_dir": 2,
"size": 10
},
}
add_io_info = AddIOInfo()
add_io_info.initialize()
log.info("io_config: %s\n" % io_config)
log.info("initiating nfs ganesha")
nfs_ganesha = PrepNFSGanesha(
mount_point=ganesha_test_config["mount_point"],
yaml_fname=ganesha_test_config["rgw_user_info"],
)
nfs_ganesha.initialize()
log.info("authenticating rgw user")
rgw_auth = Authenticate(
user_id=nfs_ganesha.user_id,
access_key=nfs_ganesha.access_key,
secret_key=nfs_ganesha.secret_key,
)
auth = rgw_auth.do_auth()
log.info("begin IO")
bdir = BaseDir(
int(io_config["base_dir_count"]),
rgw_auth.json_file_upload,
ganesha_test_config["mount_point"],
auth["conn"],
)
bdirs = bdir.create(uname=str(rgw_auth.user_id))
subdir = SubdirAndObjects(bdirs, io_config, rgw_auth.json_file_upload,
auth["conn"])
subdir.create()
op_status = subdir.operation_on_nfs(ganesha_test_config["mount_point"],
op_code="move")
verification = {"key": True, "move": True}
for ops in op_status:
if not ops["op_code_status"]:
verification["move"] = False
break
else:
log.info("verification starts")
log.info("key verifcation starts on s3")
kstatus = subdir.verify_s3()
log.info("key verificaion complete: \n%s" % kstatus)
for ks in kstatus:
if ks["type"] == "file":
if ks["exists"]:
verification["key"] = True
else:
verification["key"] = False
return verification
def test(yaml_file_path):
ganesha_test_config = {
"mount_point": "ganesha-mount",
"rgw_user_info": yaml_file_path,
}
verification = {"bucket": False, "key": False}
log.info("ganesha_test_config :%s\n" % ganesha_test_config)
io_config = {
"base_dir_count": 2,
"sub_dir_count": 2,
"Files": {"files_in_dir": 2, "size": 10},
}
add_io_info = AddIOInfo()
add_io_info.initialize()
log.info("io_config: %s\n" % io_config)
log.info("initiating nfs ganesha")
log.info(
"resetting rgw_user_info yaml file with null values to that new rgw user will be created and with new_config"
)
rgw_user_config_ops = RGWUserConfigOps(
yaml_fname=ganesha_test_config["rgw_user_info"]
)
rgw_user_config_ops.update_config()
log.info("will take new config and start the basic IO test")
log.info("--------------------------------------------------")
nfs_ganesha = PrepNFSGanesha(
mount_point=ganesha_test_config["mount_point"],
yaml_fname=ganesha_test_config["rgw_user_info"],
)
nfs_ganesha.initialize()
log.info("authenticating rgw user")
rgw_auth = Authenticate(
user_id=nfs_ganesha.user_id,
access_key=nfs_ganesha.access_key,
secret_key=nfs_ganesha.secret_key,
)
auth = rgw_auth.do_auth()
log.info("begin IO")
bdir = BaseDir(
int(io_config["base_dir_count"]),
rgw_auth.json_file_upload,
ganesha_test_config["mount_point"],
auth["conn"],
)
bdirs = bdir.create(uname=str(rgw_auth.user_id))
subdir = SubdirAndObjects(bdirs, io_config, rgw_auth.json_file_upload, auth["conn"])
subdir.create()
log.info("verification starts")
time.sleep(15)
bstatus = bdir.verify_s3()
log.info("bucket verification complete")
kstatus = subdir.verify_s3()
log.info("key verification complete")
for bs in bstatus:
if not bs["exists"]:
verification["bucket"] = False
break
else:
verification["bucket"] = True
for ks in kstatus:
if not ks["exists"]:
verification["key"] = False
if ks["type"] == "file":
if not ks["md5_matched"]:
verification["key"] = False
break
if not ks["size_matched"]:
verification["key"] = False
break
else:
verification["key"] = True
return verification
def test_exec_write(config):
add_io_info = AddIOInfo()
add_io_info.initialize()
test_info = AddTestInfo(
'give the permission for all the users and then reset it')
try:
# test case starts
test_info.started_info()
with open('user_details') as fout:
all_user_details = simplejson.load(fout)
for each_user in all_user_details:
add_io_info.add_user_info(
**{
'user_id': each_user['user_id'],
'access_key': each_user['access_key'],
'secret_key': each_user['secret_key']
})
user1 = all_user_details[0]
u1 = ObjectOps(config, user1)
log.info('user1: %s' % user1)
all_user_details.pop(0)
for each_user in all_user_details:
print('iter ------------------>')
log.info('user2: %s' % each_user)
u2 = ObjectOps(config, each_user)
u2_canonical_id = u2.canonical_id
log.info('canonical id of u2: %s' % u2_canonical_id)
log.info('setting only read permission')
grants = {'permission': 'READ', 'user_id': None, 'recursive': True}
log.info('write persmission are not set')
grants['user_id'] = u2_canonical_id
u1.grants = grants
u1.create_bucket()
u1.set_bucket_properties()
u2.bucket_names = u1.bucket_names
u2.buckets_created = u1.buckets_created
u2.json_file_upload = u1.json_file_upload
u2.json_file_download = u1.json_file_download
u2.grants = None
u2.create_bucket()
buckets = u2.set_bucket_properties()
key_created = u2.upload(buckets)
if not key_created:
log.info(
'no write permission set and hence failing to create object'
)
elif key_created:
raise AssertionError("object created even with no permission")
log.info('setting permission to write also')
grants = {
'permission': 'WRITE',
'user_id': u2_canonical_id,
'recursive': True
}
u1.grants = grants
u1.set_bucket_properties()
u2.bucket_names = u1.bucket_names
u2.buckets_created = u1.buckets_created
u2.grants = None
buckets = u2.set_bucket_properties()
key_created = u2.upload(buckets,
object_base_name=str(u2.canonical_id) +
".key")
if key_created:
log.info('object created after permission set')
log.info(
'***************** removing grants and making the bucket private *****************'
)
u1.grants = None
u1.acls = 'private'
u1.set_bucket_properties()
for each_user in all_user_details:
u2 = ObjectOps(config, each_user)
print('iter ------------------>')
u2.bucket_names = u1.bucket_names
u2.buckets_created = u1.buckets_created
u2.json_file_upload = u1.json_file_upload
u2.json_file_download = u1.json_file_download
u2.grants = None
buckets = u2.set_bucket_properties()
if not buckets:
log.info('bucket init failed: %s' % buckets)
elif buckets:
key_created = u2.upload(buckets)
if not key_created:
log.info(
'no write permission set and hence failing to create object'
)
elif key_created:
raise AssertionError(
"object created even with no permission")
test_info.success_status('test completed')
except AssertionError as e:
log.error(e)
test_info.failed_status('test failed: %s' % e)
sys.exit(1)
def test(yaml_file_path):
ganesha_test_config = {
'mount_point': 'ganesha-mount',
'rgw_user_info': yaml_file_path
}
log.info('ganesha_test_config :%s\n' % ganesha_test_config)
io_config = {
'base_dir_count': 1,
'sub_dir_count': 1,
'Files': {
'files_in_dir': 1,
'size': 10
}
}
add_io_info = AddIOInfo()
add_io_info.initialize()
log.info('io_config: %s\n' % io_config)
log.info('initiating nfs ganesha')
nfs_ganesha = PrepNFSGanesha(
mount_point=ganesha_test_config['mount_point'],
yaml_fname=ganesha_test_config['rgw_user_info'])
nfs_ganesha.initialize()
log.info('authenticating rgw user')
rgw_auth = Authenticate(user_id=nfs_ganesha.user_id,
access_key=nfs_ganesha.access_key,
secret_key=nfs_ganesha.secret_key)
auth = rgw_auth.do_auth()
log.info('begin IO')
bdir = BaseDir(int(io_config['base_dir_count']), rgw_auth.json_file_upload,
ganesha_test_config['mount_point'], auth['conn'])
bdirs = bdir.create(uname=str(rgw_auth.user_id))
subdir = SubdirAndObjects(bdirs, io_config, rgw_auth.json_file_upload,
auth['conn'])
subdir.create(file_type='text')
log.info('operation starting: %s' % 'edit')
op_status = subdir.operation_on_nfs(ganesha_test_config['mount_point'],
op_code='edit')
for op in op_status:
if not op['op_code_status']:
log.error('operation failed')
exit(1)
log.info('verification starts')
kstatus = subdir.verify_s3(op_type='edit')
log.info('key verificaion complete: \n%s' % kstatus)
return kstatus
def test(yaml_file_path):
ganesha_test_config = {
'mount_point': 'ganesha-mount',
'rgw_user_info': yaml_file_path
}
log.info('ganesha_test_config :%s\n' % ganesha_test_config)
io_config = {
'base_dir_count': 2,
'sub_dir_count': 2,
'Files': {
'files_in_dir': 2,
'size': 10
}
}
add_io_info = AddIOInfo()
add_io_info.initialize()
log.info('io_config: %s\n' % io_config)
log.info('initiating nfs ganesha')
nfs_ganesha = PrepNFSGanesha(
mount_point=ganesha_test_config['mount_point'],
yaml_fname=ganesha_test_config['rgw_user_info'])
nfs_ganesha.initialize()
log.info('authenticating rgw user')
rgw_auth = Authenticate(user_id=nfs_ganesha.user_id,
access_key=nfs_ganesha.access_key,
secret_key=nfs_ganesha.secret_key)
auth = rgw_auth.do_auth()
log.info('begin IO')
bdir = BaseDir(int(io_config['base_dir_count']), rgw_auth.json_file_upload,
ganesha_test_config['mount_point'], auth['conn'])
bdirs = bdir.create(uname=str(rgw_auth.user_id))
subdir = SubdirAndObjects(bdirs, io_config, rgw_auth.json_file_upload,
auth['conn'])
subdir.create()
log.info('verification starts')
time.sleep(15)
bstatus = bdir.verify_s3()
log.info('bucket verification complete')
kstatus = subdir.verify_s3()
log.info('key verification complete')
verification = {}
for bs in bstatus:
if not bs['exists']:
verification['bucket'] = False
break
else:
verification['bucket'] = True
for ks in kstatus:
if not ks['exists']:
verification['key'] = False
if ks['type'] == 'file':
if not ks['md5_matched']:
verification['key'] = False
break
if not ks['size_matched']:
verification['key'] = False
break
else:
verification['key'] = True
return verification
def test(yaml_file_path):
ganesha_test_config = {'mount_point': 'ganesha-mount',
'rgw_user_info': yaml_file_path}
log.info('ganesha_test_config :%s\n' % ganesha_test_config)
log.info('initiating nfs ganesha')
add_io_info = AddIOInfo()
add_io_info.initialize()
nfs_ganesha = PrepNFSGanesha(mount_point=ganesha_test_config['mount_point'],
yaml_fname=ganesha_test_config['rgw_user_info'])
nfs_ganesha.initialize()
config = Config()
config.bucket_count = 2
config.objects_count = 2
config.objects_size_range = {'min': 10, 'max': 50}
log.info('begin IO')
rgw_user = nfs_ganesha.read_config()
rgw = ObjectOps(config, rgw_user)
buckets = rgw.create_bucket()
rgw.upload(buckets)
time.sleep(20)
bdir = BaseDir(count=None, json_fname=rgw.json_file_upload, mount_point=ganesha_test_config['mount_point'],
auth=rgw.connection['conn'])
subd = SubdirAndObjects(base_dir_list=None, config=None, json_fname=rgw.json_file_upload, auth=rgw.connection['conn'])
ks_op_status = subd.operation_on_s3(op_code='delete')
verification= {'delete': True,
'key': True}
for status in ks_op_status:
if not status['op_code_status']:
verification['delete'] = False
break
if verification['delete']:
log.info('verification starts')
log.info('key verificaion starts')
kstatus = subd.verify_nfs(mount_point=ganesha_test_config['mount_point'])
log.info('key verification complete: %s' % kstatus)
for ks in kstatus:
if not ks['exists']:
verification['key'] = True
if ks['exists']:
verification['key'] = False
return verification
def test(yaml_file_path):
ganesha_test_config = {
"mount_point": "ganesha-mount",
"rgw_user_info": yaml_file_path,
}
log.info("ganesha_test_config :%s\n" % ganesha_test_config)
add_io_info = AddIOInfo()
add_io_info.initialize()
log.info("initiating nfs ganesha")
nfs_ganesha = PrepNFSGanesha(
mount_point=ganesha_test_config["mount_point"],
yaml_fname=ganesha_test_config["rgw_user_info"],
)
nfs_ganesha.initialize()
config = Config()
config.bucket_count = 1
config.objects_count = 2
config.objects_size_range = {"min": 10, "max": 50}
log.info("begin IO")
rgw_user = nfs_ganesha.read_config()
rgw = ObjectOps(config, rgw_user)
buckets = rgw.create_bucket()
rgw.upload(buckets)
time.sleep(20)
bdir = BaseDir(
count=None,
json_fname=rgw.json_file_upload,
mount_point=ganesha_test_config["mount_point"],
auth=rgw.connection["conn"],
)
subd = SubdirAndObjects(
base_dir_list=None,
config=None,
json_fname=rgw.json_file_upload,
auth=rgw.connection["conn"],
)
ks_op_status = subd.operation_on_s3(op_code="move")
time.sleep(300) # wait for 5 mins
# after move, verify on nfs for the changes
verification = {"delete": True, "key": True}
for status in ks_op_status:
if not status["op_code_status"]:
verification["delete"] = False
break
if verification["delete"]:
log.info("verification starts")
log.info("key verificaion starts")
kstatus = subd.verify_nfs(mount_point=ganesha_test_config["mount_point"])
log.info("key verification complete: %s" % kstatus)
for ks in kstatus:
if ks["exists"]:
verification["key"] = True
else:
verification["key"] = False
return verification
