async def build_get_claim_req(args, data):
"""
Build GET claim request.
:param args: arguments to build GET claim request.
:param data: ADD claim request info.
:return: GET claim request.
"""
if not data:
return ''
submitter_did = args['submitter_did']
try:
if isinstance(data, str):
data = json.loads(data)
if isinstance(data, str):
data = json.loads(data)
if data['kind'] != 'claim':
return ''
utils.print_header_for_step('Build get schema request')
issuer_did = data['data']['issuer_did']
seq_no = data['data']['seq_no']
signature_type = data['data']['signature_type']
get_claim_req = await ledger.build_get_claim_def_txn(
submitter_did, seq_no, signature_type, issuer_did)
return get_claim_req
except Exception as e:
utils.force_print_error_to_console(
"Cannot build get claim request. Skip building...")
utils.force_print_error_to_console(str(e))
return ''
async def build_get_attribute_req(args, data):
"""
Build GET attribute request.
:param args: arguments to build GET attribute request.
:param data: ADD attribute request info.
:return: GET attribute request.
"""
if not data:
return ''
submitter_did = args['submitter_did']
try:
if isinstance(data, str):
data = json.loads(data)
if isinstance(data, str):
data = json.loads(data)
if data['kind'] != 'attribute':
return ''
utils.print_header_for_step('Build get attribute request')
target_did = data['data']['target_did']
raw_name = data['data']['raw_name']
get_attr_req = await ledger.build_get_attrib_request(submitter_did,
target_did,
raw_name)
return get_attr_req
except Exception as e:
utils.force_print_error_to_console(
"Cannot build get attribute request. Skip building...")
utils.force_print_error_to_console(str(e))
return ''
async def build_get_schema_req(args, data):
"""
Build GET schema request.
:param args: arguments to build GET schema request.
:param data: ADD schema request info.
:return: GET schema request.
"""
if not data:
return ''
submitter_did = args['submitter_did']
try:
if isinstance(data, str):
data = json.loads(data)
if isinstance(data, str):
data = json.loads(data)
if data['kind'] != 'schema':
return ''
utils.print_header_for_step('Build get schema request')
dest = data['data']['dest']
schema_data = {'name': data['data']['name'],
'version': data['data']['version']}
get_schema_req = await ledger.build_get_schema_request(
submitter_did, dest, json.dumps(schema_data))
return get_schema_req
except Exception as e:
utils.force_print_error_to_console(
"Cannot build get schema request. Skip building...")
utils.force_print_error_to_console(str(e))
return ''
async def build_nym_req(args: dict):
"""
Build ADD nym request.
:param args: arguments for building ADD nym request.
:return: nym request, request info.
"""
wallet_handle = args['wallet_handle']
submitter_did = args['submitter_did']
try:
utils.print_header_for_step('Create did')
did, _, = await signus.create_and_store_my_did(wallet_handle, '{}')
# Send NYM to ledger
utils.print_header("\n======== Build NYM request ========")
nym_req = await ledger.build_nym_request(submitter_did, did, None,
None, None)
req_info = json.dumps({'kind': 'nym', 'data': {'target_did': did}})
req = json.dumps({'request': nym_req})
return req, req_info
except Exception as e:
utils.force_print_error_to_console(
"Cannot build nym request. Skip building...")
utils.force_print_error_to_console(str(e))
return ""
async def build_schema_req(args: dict):
"""
Build ADD schema request.
:param args: arguments for building ADD schema request.
:return: schema request, request info.
"""
submitter_did = args['submitter_did']
try:
data = {
'name': utils.generate_random_string(prefix='test'),
'version': '1.0',
'attr_names': ['test']
}
utils.print_header("\n======= Build schema request =======")
schema_req = await ledger.build_schema_request(submitter_did,
json.dumps(data))
del data['attr_names']
data['dest'] = submitter_did
req_info = json.dumps({'kind': 'schema', 'data': data})
req = json.dumps({'request': schema_req})
return req, req_info
except Exception as e:
utils.force_print_error_to_console(
"Cannot build schema request. Skip building...")
utils.force_print_error_to_console(str(e))
return ""
async def _test(self):
"""
Override from "Tester" class to implement testing steps.
"""
# 1. Create pool config.
# 2. Open pool ledger
# 3. Create My Wallet and Get Wallet Handle
# 4 Create and sender DID
args = {'wallet_handle': self.wallet_handle,
'pool_handle': self.pool_handle,
'submitter_did': self.submitter_did}
# 5. Build requests and save them in to files.
builder = requests_builder.RequestBuilder(self.info_file_path,
self.log)
req_files = await builder.build_several_adding_req_to_files(
args, self.req_kind, self.thread_num, self.req_num)
# 6. Sign and submit several request into ledger.
sender = requests_sender.RequestsSender(self.log)
try:
await sender.sign_and_submit_several_reqs_from_files(
args, req_files, self.req_kind)
except Exception as e:
utils.force_print_error_to_console(str(e) + "\n")
self.passed_req, self.failed_req = sender.passed_req, sender.failed_req
self.start_time, self.finish_time = (sender.start_time,
sender.finish_time)
self.fastest_txn = sender.fastest_txn
self.lowest_txn = sender.lowest_txn
def submit_reqs_in_thread(self, args, file, kind):
"""
Thread function that submit request from one request file.
:param args: arguments to submit requests.
:param file: request file (store all request you want to submit).
:param kind: kind of request.
"""
start_time = finish_time = 0
with open(file, "r") as req_file:
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
for line in req_file:
response_time = utils.run_async_method(loop, self.submit_req,
args, kind, line)
if start_time == 0:
start_time = response_time
if response_time > finish_time:
finish_time = response_time
loop.close()
try:
os.remove(file)
except IOError as e:
utils.force_print_error_to_console(str(e) + "\n")
self.update_start_and_finish_time(start_time, finish_time)
async def build_claim_req(args: dict):
"""
Build ADD claim request.
:param args: arguments to build ADD claim request.
:return: claim request, request info.
"""
import string
import random
pool_handle = args['pool_handle']
wallet_handle = args['wallet_handle']
submitter_did = args['submitter_did']
try:
utils.print_header("\n======= Create did =======")
did, verkey = await signus.create_and_store_my_did(wallet_handle,
'{}')
utils.print_header("\n======= Build nym request =======")
nym_req = await ledger.build_nym_request(submitter_did, did,
verkey,
None, None)
utils.print_header("\n======= Send nym request =======")
await ledger.sign_and_submit_request(pool_handle, wallet_handle,
submitter_did, nym_req)
seq_no = random.randint(1, 1000000)
signature_type = 'CL'
data = {"primary": {
"n": utils.generate_random_string(characters=string.digits),
"s": utils.generate_random_string(characters=string.digits),
"rms": utils.generate_random_string(characters=string.digits),
"r": {"name": utils.generate_random_string(
characters=string.digits)},
"rctxt": utils.generate_random_string(
characters=string.digits),
"z": utils.generate_random_string(characters=string.digits)}}
utils.print_header("\n======= Build claim request =======")
claim_req = await ledger.build_claim_def_txn(did, seq_no,
signature_type,
json.dumps(data))
req_info = json.dumps({'kind': 'claim',
'data': {'issuer_did': did,
'seq_no': seq_no,
'signature_type': signature_type}})
req = json.dumps({'request': claim_req, 'submitter_did': did})
return req, req_info
except Exception as e:
utils.force_print_error_to_console(
"Cannot build claim request. Skip building...")
utils.force_print_error_to_console(str(e))
return ""
def __collect_requests_info_files(self):
"""
Collect all request info file from directory.
:return: list of file name.
"""
lst_files = glob.glob(
os.path.join(self.info_dir,
'{}_requests_info*{}'.format(self.req_kind, '.txt')))
if not lst_files:
utils.force_print_error_to_console(
'Cannot found any request info. '
'Skip sending get request... Abort')
sys.exit(1)
return lst_files
def __collect_requests_info_files(self):
"""
Collect all request info file from directory.
:return: list of file name.
"""
lst_files = glob.glob(os.path.join(
self.info_dir, '{}_requests_info*{}'.format(self.req_kind,
'.txt')))
if not lst_files:
utils.force_print_error_to_console(
'Cannot found any request info. '
'Skip sending get request... Abort')
sys.exit(1)
return lst_files
async def build_attribute_req(args: dict):
"""
Build ADD attribute request.
:param args: arguments to build ADD attribute request.
:return: attribute request, request info.
"""
pool_handle = args['pool_handle']
wallet_handle = args['wallet_handle']
submitter_did = args['submitter_did']
try:
utils.print_header("\n======= Create did =======")
did, verkey = await signus.create_and_store_my_did(wallet_handle,
'{}')
utils.print_header("\n======= Build nym request =======")
nym_req = await ledger.build_nym_request(submitter_did, did,
verkey,
None, None)
utils.print_header("\n======= Send nym request =======")
await ledger.sign_and_submit_request(pool_handle, wallet_handle,
submitter_did, nym_req)
data = {'endpoint': {'ha': '127.0.0.1:5555'}}
utils.print_header("\n======= Build attribute request =======")
attr_req = await ledger.build_attrib_request(did, did, None,
json.dumps(data),
None)
req_info = json.dumps({'kind': 'attribute',
'data': {'target_did': did,
'raw_name': 'endpoint'}})
req = json.dumps({'request': attr_req, 'submitter_did': did})
return req, req_info
except Exception as e:
utils.force_print_error_to_console(
"Cannot build attribute request. Skip building...")
utils.force_print_error_to_console(str(e))
return ""
def __init__(self):
self.options = Options().args
self.tester = None
temp = 0
for mode in PerformanceTestRunner.modes:
if mode in sys.argv:
temp += 1
if temp == 0:
utils.print_error(
'Cannot determine any kind of request for testing')
utils.print_error(
'May be you missing arguments "-a" or "-b" or "-t" or "-l"')
sys.exit(1)
if temp > 1:
utils.force_print_error_to_console(
'"-a" and "-g" and "-t" and "-l" '
'cannot exist at the same time\n')
sys.exit(1)
self.list_tester = list()
self.start_time = self.finish_time = 0
self.lowest = self.fastest = 0
self.passed_req = self.failed_req = 0
self.result_path = os.path.join(os.path.dirname(__file__), 'results')
utils.create_folder(self.result_path)
log_path = os.path.join(os.path.dirname(__file__), 'logs')
utils.create_folder(log_path)
now = time.strftime("%d-%m-%Y_%H-%M-%S")
self.result_path = os.path.join(self.result_path,
'result_{}.txt'.format(now))
log_path = os.path.join(
log_path, self.create_log_file_name())
requests_sender.RequestsSender.init_log_file(log_path)
utils.create_folder(self.options.info_dir)
async def sign_and_submit_req(self, args, kind, data):
"""
Sign and submit one request to ledger.
:param args: arguments to sign and submit requests.
:param kind: kind of request.
:param data: request info.
"""
wallet_handle = args['wallet_handle']
pool_handle = args['pool_handle']
submitter_did = args['submitter_did']
req_data = json.loads(data)
if 'submitter_did' in req_data:
submitter_did = req_data['submitter_did']
req = req_data['request']
elapsed_time = 0
response_time = None
try:
utils.print_header_for_step('Sending {} request'.format(kind))
start_time = time.time()
response = await ledger.sign_and_submit_request(
pool_handle, wallet_handle, submitter_did, req)
response_time = time.time()
elapsed_time = response_time - start_time
self.update_fastest_and_lowest_txn(elapsed_time)
self.passed_req += 1
self.print_success_msg(kind, response)
status = True
except Exception as e:
self.print_error_msg(kind, req)
utils.force_print_error_to_console(str(e) + "\n")
self.failed_req += 1
status = False
RequestsSender.print_log(status, elapsed_time, req)
return response_time
def __init__(self):
self.options = Options().args
self.tester = None
temp = 0
for mode in PerformanceTestRunner.modes:
if mode in sys.argv:
temp += 1
if temp == 0:
utils.print_error(
'Cannot determine any kind of request for testing')
utils.print_error(
'May be you missing arguments "-a" or "-b" or "-t" or "-l"')
sys.exit(1)
if temp > 1:
utils.force_print_error_to_console(
'"-a" and "-g" and "-t" and "-l" '
'cannot exist at the same time\n')
sys.exit(1)
self.list_tester = list()
self.start_time = self.finish_time = 0
self.lowest = self.fastest = 0
self.passed_req = self.failed_req = 0
self.result_path = os.path.join(os.path.dirname(__file__), 'results')
utils.create_folder(self.result_path)
log_path = os.path.join(os.path.dirname(__file__), 'logs')
utils.create_folder(log_path)
now = time.strftime("%d-%m-%Y_%H-%M-%S")
self.result_path = os.path.join(self.result_path,
'result_{}.txt'.format(now))
log_path = os.path.join(log_path, self.create_log_file_name())
requests_sender.RequestsSender.init_log_file(log_path)
utils.create_folder(self.options.info_dir)
async def submit_req(self, args, kind, data):
"""
Submit one request to ledger.
:param args: arguments to submit requests.
:param kind: kind of request.
:param data: request info.
:return:
"""
pool_handle = args['pool_handle']
req = data
elapsed_time = 0
response_time = None
try:
utils.print_header_for_step('Sending get {} request'.format(kind))
start_time = time.time()
response = await ledger.submit_request(pool_handle, req)
response_time = time.time()
elapsed_time = response_time - start_time
self.passed_req += 1
self.update_fastest_and_lowest_txn(elapsed_time)
self.print_success_msg(kind, response)
status = True
except Exception as e:
self.print_error_msg(kind, req)
utils.force_print_error_to_console(str(e) + "\n")
self.failed_req += 1
status = False
RequestsSender.print_log(status, elapsed_time, req)
return response_time
def print_error_msg(kind, request):
"""
Print error message to console.
"""
utils.force_print_error_to_console(
'\nCannot submit {} request:\n{}'.format(kind, request))
