def __init__(self, user_info, **extra_kwargs): """ Initializes the variables of user_info parameter """ self.access_key = user_info["access_key"] self.secret_key = user_info["secret_key"] self.hostname = socket.gethostname() self.ip = socket.gethostbyname(self.hostname) self.ssl = extra_kwargs.get("ssl", False) self.port = utils.get_radosgw_port_no() self.endpoint_url = ( "https://{}:{}".format(self.ip, self.port) if self.ssl else "http://{}:{}".format(self.ip, self.port) ) self.is_secure = False self.user_id = user_info["user_id"] self.session_token = user_info.get("session_token") log.info("access_key: %s" % self.access_key) log.info("secret_key: %s" % self.secret_key) log.info("hostname: %s" % self.hostname) log.info("port: %s" % self.port) log.info("user_id: %s" % self.user_id) log.info("endpoint url: %s" % self.endpoint_url) log.info("ssl: %s" % self.ssl) log.info("session_token: %s" % self.session_token)
def __init__(self): self._hostname, self._ip = utils.get_hostname_ip() self._ssl_port = 443 self._non_ssl_port = utils.get_radosgw_port_no() self._ceph_conf = CephConfOp() self._rgw_service = RGWService() # _sections_to_check = ['client.rgw.' + self._hostname, # 'client.rgw.' + self._ip] # log.info('checking for existence of sections: {}'.format(_sections_to_check)) # _sections = [section for section in _sections_to_check if self._ceph_conf.check_if_section_exists(section)] # # log.info('got section(s): {}'.format(_sections)) # if not any(_sections): # raise RGWBaseException('No RGW section in ceph.conf') # self.section = _sections[0] sections_in_ceph_conf = self._ceph_conf.cfg.sections() log.info( 'got sections from ceph_conf: {}'.format(sections_in_ceph_conf)) rgw_section = list( filter(lambda section: 'rgw' in section, sections_in_ceph_conf)) if not rgw_section: raise RGWBaseException('No RGW section in ceph.conf') self.section = rgw_section[0] log.info('using section: {}'.format(self.section))
def test_exec(config): io_info_initialize = IOInfoInitialize() basic_io_structure = BasicIOInfoStructure() io_info_initialize.initialize(basic_io_structure.initial()) umgmt = UserMgmt() # preparing data user_names = ["tuffy", "scooby", "max"] tenant = "tenant" tenant_user_info = umgmt.create_tenant_user(tenant_name=tenant, user_id=user_names[0], displayname=user_names[0]) user_info = umgmt.create_subuser(tenant_name=tenant, user_id=user_names[0]) cmd = "radosgw-admin quota enable --quota-scope=user --uid={uid} --tenant={tenant}".format( uid=user_names[0], tenant=tenant) enable_user_quota = utils.exec_shell_cmd(cmd) cmd = "radosgw-admin quota set --quota-scope=user --uid={uid} --tenant={tenant} --max_buckets=2000".format( uid=user_names[0], tenant=tenant) max_bucket = utils.exec_shell_cmd(cmd) auth = Auth(user_info) rgw = auth.do_auth() for cc in range(config.container_count): container_name = utils.gen_bucket_name_from_userid( user_info["user_id"], rand_no=cc) container = swiftlib.resource_op({ "obj": rgw, "resource": "put_container", "args": [container_name] }) if container is False: raise TestExecError( "Resource execution failed: container creation faield") host, ip = utils.get_hostname_ip() port = utils.get_radosgw_port_no() hostname = str(ip) + ":" + str(port) cmd = "swift -A http://{hostname}/auth/1.0 -U '{uid}' -K '{key}' stat".format( hostname=hostname, uid=user_info["user_id"], key=user_info["key"]) swift_cmd = utils.exec_shell_cmd(cmd) swift_cmd = swift_cmd.replace(" ", "") swift_cmd = swift_cmd.replace("\n", ":") li = list(swift_cmd.split(":")) res_dct = {li[i]: li[i + 1] for i in range(0, len(li) - 1, 2)} if int(res_dct["Containers"]) == config.container_count: cmd = "radosgw-admin user rm --uid={uid} --tenant={tenant} --purge-data".format( uid=user_names[0], tenant=tenant) delete_user_bucket = utils.exec_shell_cmd(cmd) test_info.success_status("test passed") sys.exit(0) else: cmd = "radosgw-admin user rm --uid={uid} --tenant={tenant} --purge-data".format( uid=user_names[0], tenant=tenant) delete_user_bucket = utils.exec_shell_cmd(cmd) test_info.failed_status("test failed") sys.exit(1)
def __init__(self, user_info): """ Initializes the user_info variables """ self.secret_key = user_info["key"] self.hostname = socket.gethostname() self.port = int(utils.get_radosgw_port_no()) self.is_secure = False self.user_id = user_info["user_id"]
def get_rgw_ip_and_port(): """ Returns RGW ip and port in <ip>:<port> format Returns: RGW ip and port """ hostname = socket.gethostname() ip = socket.gethostbyname(hostname) port = utils.get_radosgw_port_no() ip_and_port = f"{ip}:{port}" return ip_and_port
def verify_io(self): """ This function to verify the data of buckets owned by a user Data verification happens to all the buckets of a particular user for both versioned and normal buckets Parameters: Returns: """ log.info("***************Starting Verification*****************") data = self.file_op.get_data() users = data["users"] is_secure = True if utils.is_rgw_secure() else False host = socket.gethostbyname(socket.gethostname()) endpoint_proto = "https" if is_secure else "http" endpoint_port = utils.get_radosgw_port_no() endpoint_url = f"{endpoint_proto}://{host}:{endpoint_port}" for each_user in users: log.info("verifying data for the user: \n") log.info("user_id: %s" % each_user["user_id"]) log.info("access_key: %s" % each_user["access_key"]) log.info("secret_key: %s" % each_user["secret_key"]) conn = boto3.resource( "s3", aws_access_key_id=each_user["access_key"], aws_secret_access_key=each_user["secret_key"], endpoint_url=endpoint_url, use_ssl=is_secure, verify=False, ) for each_bucket in each_user["bucket"]: log.info("verifying data for bucket: %s" % each_bucket["name"]) bucket_from_s3 = conn.Bucket(each_bucket["name"]) curr_versioning_status = each_bucket["curr_versioning_status"] log.info("curr_versioning_status: %s" % curr_versioning_status) if not each_bucket["keys"]: log.info("keys are not created") else: no_of_keys = len(each_bucket["keys"]) log.info("no_of_keys: %s" % no_of_keys) for each_key in each_bucket["keys"]: versioned_keys = len(each_key["versioning_info"]) log.info("versioned_keys: %s" % versioned_keys) if not each_key["versioning_info"]: log.info("not versioned key") verify_key(each_key, bucket_from_s3) else: log.info("versioned key") verify_key_with_version(each_key, bucket_from_s3) log.info("verification of data completed")
def __init__(self, access_key, secret_key, user_id, port=None): log.debug("class: %s" % self.__class__.__name__) self.access_key = access_key self.secret_key = secret_key self.hostname = socket.gethostname() self.port = int(utils_v2.get_radosgw_port_no()) self.is_secure = False self.user_id = user_id self.json_file_upload = self.user_id + "." + "upload" + "." + "json" self.json_file_download = self.user_id + "." + "download" + "." + "json"
def test_exec(config): """ Executes test based on configuration passed Args: config(object): Test configuration """ io_info_initialize = IOInfoInitialize() basic_io_structure = BasicIOInfoStructure() io_info_initialize.initialize(basic_io_structure.initial()) umgmt = UserMgmt() ceph_conf = CephConfOp() rgw_service = RGWService() # preparing data user_name = resource_op.create_users(no_of_users_to_create=1)[0]["user_id"] tenant = "tenant" tenant_user_info = umgmt.create_tenant_user(tenant_name=tenant, user_id=user_name, displayname=user_name) user_info = umgmt.create_subuser(tenant_name=tenant, user_id=user_name) hostname = socket.gethostname() ip = socket.gethostbyname(hostname) port = utils.get_radosgw_port_no() ip_and_port = f"{ip}:{port}" s3_auth.do_auth(tenant_user_info, ip_and_port) bucket_name = utils.gen_bucket_name_from_userid(user_name, rand_no=0) # Create a bucket s3cmd_reusable.create_bucket(bucket_name) log.info(f"Bucket {bucket_name} created") # Upload file to bucket uploaded_file_info = s3cmd_reusable.upload_file( bucket_name, test_data_path=TEST_DATA_PATH) uploaded_file = uploaded_file_info["name"] log.info(f"Uploaded file {uploaded_file} to bucket {bucket_name}") # Delete file from bucket s3cmd_reusable.delete_file(bucket_name, uploaded_file) log.info(f"Deleted file {uploaded_file} from bucket {bucket_name}") # Delete bucket s3cmd_reusable.delete_bucket(bucket_name) log.info(f"Bucket {bucket_name} deleted") # check for any crashes during the execution crash_info = reusable.check_for_crash() if crash_info: raise TestExecError("ceph daemon crash found!")
def verify_io(self): """ This function to verify the data of buckets owned by a user Data verification happens to all the buckets of a particular user for both versioned and normal buckets Parameters: Returns: """ log.info('***************Starting Verification*****************') data = self.file_op.get_data() users = data['users'] for each_user in users: log.info('verifying data for the user: \n') log.info('user_id: %s' % each_user['user_id']) log.info('access_key: %s' % each_user['access_key']) log.info('secret_key: %s' % each_user['secret_key']) conn = boto3.resource( 's3', aws_access_key_id=each_user['access_key'], aws_secret_access_key=each_user['secret_key'], endpoint_url='http://%s:%s' % (socket.gethostbyname( socket.gethostname()), int(utils.get_radosgw_port_no())), use_ssl=False) for each_bucket in each_user['bucket']: log.info('verifying data for bucket: %s' % each_bucket['name']) bucket_from_s3 = conn.Bucket(each_bucket['name']) curr_versioning_status = each_bucket['curr_versioning_status'] log.info('curr_versioning_status: %s' % curr_versioning_status) if not each_bucket['keys']: log.info('keys are not created') else: no_of_keys = len(each_bucket['keys']) log.info('no_of_keys: %s' % no_of_keys) for each_key in each_bucket['keys']: versioned_keys = len(each_key['versioning_info']) log.info('versioned_keys: %s' % versioned_keys) if not each_key['versioning_info']: log.info('not versioned key') verify_key(each_key, bucket_from_s3) else: log.info('versioned key') verify_key_with_version(each_key, bucket_from_s3) log.info('verification of data completed')
def __init__(self, user_info, **extra_kwargs): self.access_key = user_info['access_key'] self.secret_key = user_info['secret_key'] self.hostname = socket.gethostname() self.ip = socket.gethostbyname(self.hostname) self.ssl = extra_kwargs.get('ssl', False) self.port = utils.get_radosgw_port_no() self.endpoint_url = 'https://{}:{}'.format(self.ip, self.port) if self.ssl \ else 'http://{}:{}'.format(self.ip, self.port) self.is_secure = False self.user_id = user_info['user_id'] log.info('access_key: %s' % self.access_key) log.info('secret_key: %s' % self.secret_key) log.info('hostname: %s' % self.hostname) log.info('port: %s' % self.port) log.info('user_id: %s' % self.user_id) log.info('endpoint url: %s' % self.endpoint_url) log.info('ssl: %s' % self.ssl)
def test_exec(config): io_info_initialize = IOInfoInitialize() basic_io_structure = BasicIOInfoStructure() io_info_initialize.initialize(basic_io_structure.initial()) umgmt = UserMgmt() host, ip = utils.get_hostname_ip() port = utils.get_radosgw_port_no() hostname = str(ip) + ":" + str(port) log.info(hostname) # preparing data admin_api_user = "******" + randomString() log.info(admin_api_user) user_info = umgmt.create_rest_admin_user(user_id=admin_api_user, displayname=admin_api_user) rgw = RGWAdmin(access_key=user_info['access_key'], secret_key=user_info['secret_key'], server=hostname, secure=False, verify=False) api_user = "******" + randomString() log.info(api_user) for uc in range(config.user_count): #Create User data = rgw.create_user(uid=api_user, display_name=api_user, email=api_user + '@abc.xyz') log.info("User created successfully") log.info(data) log.info('verification starts') op = utils.exec_shell_cmd("radosgw-admin user info --uid %s" % api_user) json_doc = json.loads(op) log.info(json_doc) v = verify_user(data, json_doc) if v is False: test_info.failed_status('test failed') sys.exit(1) log.info("Verification for create operation completed") #Update User data = rgw.modify_user(uid=api_user, display_name=api_user + "_11", email=api_user + '*****@*****.**') log.info("User Updated successfully") log.info(data) log.info('verification starts') op = utils.exec_shell_cmd("radosgw-admin user info --uid %s" % api_user) json_doc = json.loads(op) log.info(json_doc) v = verify_user(data, json_doc) if v is False: test_info.failed_status('test failed') sys.exit(1) log.info("Verification for Update operation completed") #delete User data = rgw.remove_user(uid=api_user, purge_data=False) log.info(data) log.info("User removed") op = utils.exec_shell_cmd("radosgw-admin user list") json_doc = json.loads(op) if api_user in json_doc: test_info.failed_status('test failed') sys.exit(1) log.info("Verification for Delete operation completed") # check for any crashes during the execution crash_info = reusable.check_for_crash() if crash_info: raise TestExecError("ceph daemon crash found!")
def __init__(self, user_info): self.secret_key = user_info['key'] self.hostname = socket.gethostname() self.port = int(utils.get_radosgw_port_no()) self.is_secure = False self.user_id = user_info['user_id']