def run_single_task(task, judge=True, process_log=True):
connecttype = task.type()
name = task.name()
start_time = time.time()
if process_log:
logger.print("[-------------------------------]")
logger.print("[ CONNECT ] " + str(connecttype) + "." + str(name))
cfg_content = task.data()
cfg_request = cfg_content["REQUEST"]
cfg_response = cfg_content["RESPONSE"]
if process_log:
logger.print(
"[ REQUEST ]" +
json.dumps(cfg_content, indent=4, sort_keys=True).replace(
"\"num#!#start-", "").replace("-num#!#end\"", ""))
# (result, response) = self.multithread_run(logger, cfg_request, cfg_response)
node_index = task.node_index()
node_ip = None
if node_index is None:
node_index = 0
if connecttype.lower() == "rpc":
node_ip = Config.NODES[int(node_index)]["ip"] + ":" + str(
Config.NODES[int(node_index)]["rpcport"])
if connecttype.lower() == "st":
node_ip = Config.NODES[int(node_index)]["ip"] + ":" + str(
Config.NODES[int(node_index)]["stport"])
logger.print("run on service(" + str(node_index) + "): " + node_ip)
response = utils.connect.con(connecttype, node_ip, cfg_request)
if process_log:
logger.print("[ RESPONSE ]" + json.dumps(response, indent=4))
end_time = time.time()
time_consumed = (end_time - start_time) * 1000
result = True
if judge:
result = Common.cmp(cfg_response, response)
if process_log:
if result:
logger.print("[ OK ] " + connecttype + "." + name +
" (%d ms)" % (time_consumed))
else:
logger.print("[ Failed ] " + connecttype + "." + name +
" (%d ms)" % (time_consumed))
logger.print("[-------------------------------]")
logger.print("")
return (result, response)
def run_single_task(task, judge=True, process_log=True):
try:
connecttype = task.type()
name = task.name()
start_time = time.time()
if process_log:
logger.print("[-------------------------------]")
logger.print("[ RUN ] " + connecttype + "." + name)
cfg_content = task.data()
cfg_request = cfg_content["REQUEST"]
cfg_response = cfg_content["RESPONSE"]
if process_log:
logger.print("[ PARAMS ]" +
json.dumps(cfg_content, indent=4))
#(result, response) = self.multithread_run(logger, cfg_request, cfg_response)
node_index = task.node_index()
node_ip = None
print(node_index)
if node_index != None:
node_ip = Config.NODES[int(node_index)]["ip"]
print("run on other service: " + str(node_index) + " " +
node_ip)
response = utils.connect.con(connecttype, node_ip, cfg_request)
if process_log:
logger.print("[ RESULT ]" + json.dumps(response, indent=4))
end_time = time.time()
time_consumed = (end_time - start_time) * 1000
result = True
if judge:
result = Common.cmp(cfg_response, response)
if process_log:
if result:
logger.print("[ OK ] " + connecttype + "." +
name + " (%d ms)" % (time_consumed))
else:
logger.print("[ Failed ] " + connecttype + "." +
name + " (%d ms)" % (time_consumed))
logger.print("[-------------------------------]")
logger.print("")
return (result, response)
except TestError as e:
print(e.msg)
return (False, None)
except Exception as e:
print(e)
return (False, None)
def run_pair_task(task1,
task2,
compare_src_key=None,
compare_dist_key=None):
result = True
(result1, response1) = TaskRunner.run_single_task(task1)
if not result1:
return result1
(result2, response2) = TaskRunner.run_single_task(task2)
if not result2:
return result2
compare_src_data = response1
if compare_src_key:
compare_src_keys = compare_src_key.split('/')
for key in compare_src_keys:
if compare_src_data:
compare_src_data = compare_src_data[key]
else:
break
# split dist key
compare_dist_data = response2
if compare_dist_key:
compare_dist_keys = compare_dist_key.split('/')
for key in compare_dist_keys:
if compare_dist_data:
compare_dist_data = compare_dist_data[key]
else:
break
result = Common.cmp(compare_src_data, compare_dist_data)
else:
result = True
return result
def call_multisig_contract(self,
task,
m,
pubkeyArray,
sleep=5,
check_state=True):
try:
taskdata = task.data()
expect_signresponse = None
expect_response = None
if "RESPONSE" in taskdata:
expect_response = taskdata["RESPONSE"]
if "SIGN_RESPONSE" in taskdata:
expect_signresponse = taskdata["SIGN_RESPONSE"]
(result, response) = self.sign_transction(
task) #Task(name="multi", ijson=request))
if not result:
logger.error("call_multisig_contract.sign_transction error!")
return (result, response)
if expect_signresponse != None:
result = Common.cmp(expect_signresponse, response)
if result and "error_code" in response and int(
response["error_code"]) != 0:
return (result, response)
if not result:
raise Error("not except sign result")
signed_tx = response["result"]["signed_tx"]
#print(request1)
execNum = 0
signed_raw = signed_tx
for pubkey in pubkeyArray:
request1 = {
"REQUEST": {
"qid": "1",
"method": "sigmutilrawtx",
"params": {
"raw_tx": signed_raw,
"m": m,
"pub_keys": pubkeyArray
}
},
"RESPONSE": {
"error_code": 0
}
}
for node_index in range(len(Config.NODES)):
if Config.NODES[node_index]["pubkey"] == pubkey:
request1["NODE_INDEX"] = node_index
(result, response) = self.sign_multi_transction(
Task(name="multi", ijson=request1))
if not result:
logger.error(
"call_multisig_contract.sign_multi_transction error![1]"
)
return (result, response)
if "error_code" not in response or response[
"error_code"] != 0:
logger.error(
"call_multisig_contract.sign_multi_transction error![2]"
)
return (False, response)
signed_raw = response["result"]["signed_tx"]
logger.info("multi sign tx:" + str(execNum) + pubkey)
execNum = execNum + 1
break
if execNum >= m:
(result,
response) = self.call_signed_contract(signed_raw, True)
(result2,
response2) = self.call_signed_contract(signed_raw, False)
#判断交易state是否成功，代替等待区块
if response and response2 and "result" in response2:
response["txhash"] = response2["result"]
if check_state and response and ("txhash" in response):
result2 = nodeapi.wait_tx_result(response["txhash"])
result3 = False
if response["error"] == 0:
result3 = result2
else:
result3 = not result2
if not result3:
raise Error("tx state not match")
if expect_response:
result = Common.cmp(expect_response, response)
#if not result:
# raise Error("not except result")
time.sleep(sleep)
return (result, response)
return (False, {
"error_info":
"multi times lesss than except!only " + str(execNum)
})
except Exception as e:
return (False, {"error_info": e})
def call_contract(self,
task,
judge=True,
pre=True,
twice=False,
sleep=5,
check_state=True):
try:
logger.print("\n")
logger.print("[-------------------------------]")
logger.print("[ RUN ] " + "contract" + "." + task.name())
taskdata = task.data()
node_index = None
deploy_first = False
deploy_code_path = None
deploy_contract_addr = None
for key in taskdata:
if key.upper() == "DEPLOY":
deploy_first = taskdata[key]
if key.upper() == "CODE_PATH":
deploy_code_path = taskdata[key]
if key.upper() == "NODE_INDEX":
node_index = int(taskdata[key])
if deploy_first:
deploy_contract_addr = self.deploy_contract(deploy_code_path)
#step 1: signed tx
expect_response = None
expect_signresponse = None
if "RESPONSE" in taskdata:
expect_response = taskdata["RESPONSE"]
if "SIGN_RESPONSE" in taskdata:
expect_signresponse = taskdata["SIGN_RESPONSE"]
if deploy_contract_addr:
taskdata["REQUEST"]["Params"][
"address"] = deploy_contract_addr.strip()
(result, response) = self.sign_transction(task, True, False)
task.data()["RESPONSE"] = response
logger.print("[ SIGNED TX ] " + json.dumps(taskdata, indent=4))
#step 2: call contract
if expect_signresponse != None:
result = Common.cmp(expect_signresponse, response)
if result and "error_code" in response and int(
response["error_code"]) != 0:
return (result, response)
if not result:
raise Error("not except sign result")
signed_tx = None
if not response is None and "result" in response and not response[
"result"] is None and "signed_tx" in response["result"]:
signed_tx = response["result"]["signed_tx"]
if signed_tx == None or signed_tx == '':
raise Error("no signed tx")
if twice:
(result,
response) = self.call_signed_contract(signed_tx, True,
node_index)
(result2, response2) = self.call_signed_contract(
signed_tx, False, node_index)
if response and response2 and "result" in response2:
response["txhash"] = response2["result"]
else:
(result,
response) = self.call_signed_contract(signed_tx, pre,
node_index)
if not pre:
response["txhash"] = response["result"]
if response is None or "error" not in response: # or str(response["error"]) != '0':
raise Error("call contract error")
response["signed_tx"] = signed_tx
if deploy_contract_addr:
response["address"] = taskdata["REQUEST"]["Params"]["address"]
#判断交易state是否成功，代替等待区块
if check_state and response and ("txhash" in response) and (
twice or pre == False):
result2 = nodeapi.wait_tx_result(response["txhash"])
if twice:
result3 = False
if response["error"] == 0:
result3 = result2
else:
result3 = not result2
if not result3:
raise Error("tx state not match")
if judge and expect_response:
result = Common.cmp(expect_response, response)
#if not result:
# raise Error("not except result")
#time.sleep(sleep)
return (result, response)
except Error as err:
return (False, {"error_info": err.msg})
