def wait_tx_result(self, txhash): for i in range(Config.GEN_BLOCK_TIMEOUT): time.sleep(1) (ret, response) = RPC_API.getsmartcodeevent(tx_hash=txhash, process_log=False) if ret: try: logger.info("tx hash:" + str(txhash) + " " + json.dumps(response)) state = response["result"]["State"] if state == 1: logger.info("tx hash:" + str(txhash) + " state = 1") return True else: return False except Exception as e: logger.print( "tx hash:" + str(txhash) + " no tx state info, may be block not generate yet...") continue else: logger.error("tx hash:" + str(txhash) + " getsmartcodeevent error") return False logger.error("tx hash:" + str(txhash) + " state timeout!") return False
def sftp_transfer_dir(_from, _to, _node_index, _op="get"): # on local host if _node_index == 0: cmd = "cp -rf " + _from + " " + _to os.system(cmd) return private_key = paramiko.RSAKey.from_private_key_file( "../../resource/id_rsa", "367wxd") transport = paramiko.Transport((Config.NODES[_node_index]["ip"], 22)) transport.connect(username="******", pkey=private_key) sftp = paramiko.SFTPClient.from_transport(transport) try: sftp.mkdir(_to) except: pass for item in os.listdir(_from): if _op == "put": sftp.put(os.path.join(_from, item), os.path.join(_to, item)) elif _op == "get": sftp.get(os.path.join(_from, item), os.path.join(_to, item)) else: logger.error("operation not supported") transport.close()
def test_22(self): try: API.node().sftp_transfer("SFTPTEST.txt", Config.NODES[0]["path"].replace("neo-cli.dll", ""), 0) ''' API.clirpc(0).terminate() API.clirpc(1).terminate() API.clirpc(2).terminate() API.clirpc(3).terminate() return API.node().clear_block() API.node(1).clear_block() API.node(2).clear_block() API.node(3).clear_block() API.clirpc(0).init("clirpc0", Config.NODES[0]["path"]) API.clirpc(0).exec(False) API.clirpc(1).init("clirpc1", Config.NODES[1]["path"]) API.clirpc(1).exec(False) API.clirpc(2).init("clirpc2", Config.NODES[2]["path"]) API.clirpc(2).exec(False) API.clirpc(3).init("clirpc3", Config.NODES[3]["path"]) API.clirpc(3).exec(False) ''' except AssertError as e: logger.error(e.msg) except Exception as e: logger.error(traceback.format_exc())
def test_base_001_benefit(self): process = False try: address1 = Config.NODES[1]["address"] (process, response) = API.rpc().getbalance(address1) self.BLOCK(process, "get balance error") ong1 = int(response["result"]["ong"]) (process, response) = API.native().transfer_ont( Config.NODES[0]["address"], Config.NODES[0]["address"], "1", gas_price=test_config.PRICE_TEST) #判断是否分润,至少需要等待1个共识时间 (process, response) = API.native().commit_dpos(sleep=0) self.BLOCK(process, "can't gen block") API.node().wait_gen_block() (process, response) = API.rpc().getbalance(address1) self.BLOCK(process, "get balance error") ong2 = int(response["result"]["ong"]) logger.info("before cost[1]: " + str(ong1)) logger.info("after cost[1]: " + str(ong2)) self.ASSERT(ong2 != ong1, "get balance error") except Exception as e: logger.error(e.args[0])
def __init__(self, code): self.code = code self.msg = "UNKNOW ERROR" if code in Config.ERR_CODE: self.msg = Config.ERR_CODE[code] logger.error(self.msg)
def con_restful(ip, api_request): try: url = "" if ip: url = "http://" + ip + ":20334" else: url = Config.RESTFUL_URL api_url = url + api_request["api"] api_command = "GET" if "command" in api_request: api_command = api_request["command"] if api_command == "POST": api_post_data = None if "params" in api_request: api_post_data = api_request["params"] api_post_data_encode = json.dumps(api_post_data) api_post_data_encode = bytes(api_post_data_encode, 'utf8') req = urllib.request.Request(url=api_url, data=api_post_data_encode) response = urllib.request.urlopen(req) return json.loads(response.read().decode("utf-8")) else: response = urllib.request.urlopen(api_url) return json.loads(response.read().decode("utf-8")) except Exception as e: logger.error("con_restful:" + str(e.args[0])) raise TestError(54002)
def test_02_getaccountstate(self): try: result = API.rpc().getaccountstate( Config.NODES[0]["wallet"].account().address()) self.ASSERT(result, "") except Exception as e: logger.error(traceback.format_exc())
def approve(contract_address,pay_address,get_address, amount,node_index = None,errorcode=47001,errorkey="error"): if len(get_address)!=34 : send_get_address=ByteToHex(bytes(get_address, encoding = "utf8")) else: send_get_address=Common.bl_address(get_address) if send_get_address=="0000000000000000000000000000000000000000": send_get_address=ByteToHex(bytes(get_address, encoding = "utf8")) if len(pay_address)!=34 : send_pay_address=ByteToHex(bytes(pay_address, encoding = "utf8")) else: send_pay_address=Common.bl_address(pay_address) if send_pay_address=="0000000000000000000000000000000000000000": send_pay_address=ByteToHex(bytes(pay_address, encoding = "utf8")) request = { "REQUEST": { "Qid": "t", "Method": "signeovminvoketx", "Params": { "gas_price": 0, "gas_limit": 1000000000, "address": contract_address, "version": 1, "params": [ { "type": "string", "value": "approve" }, { "type": "array", "value": [ { "type": "bytearray", "value": send_pay_address }, { "type": "bytearray", "value": send_get_address }, { "type": "int", "value": amount } ] } ] } }, "RESPONSE":{"error" : errorcode}, "NODE_INDEX":node_index } if (errorkey =="error_code"): request["SIGN_RESPONSE"]={errorkey : errorcode} if len(contract_address)<=5: logger.error("contract address error! now is contract address:\"" + contract_address+"\"") return (False,{"error":10000,"desc":"contract address error!"}) return API.contract().call_contract(Task(name="approve", ijson=request), twice = True,sleep=0)
def deploy_contract_full(self, neo_code_path, name="name", desc="this is desc", price=0): try: if not neo_code_path or neo_code_path == "": return None deploy_contract_addr = None deploy_contract_txhash = None logger.print("[ DEPLOY ] ") cmd = Config.TOOLS_PATH + "/deploy_contract.sh " + neo_code_path + " \"" + name + "\" \"" + desc + "\" \"" + str( price) + "\" > tmp" logger.print(cmd) p = subprocess.Popen(cmd, stderr=subprocess.STDOUT, stdout=subprocess.PIPE, shell=True) begintime = time.time() secondpass = 0 timeout = 3 while p.poll() is None: secondpass = time.time() - begintime if secondpass > timeout: p.terminate() logger.error("Error: execute " + cmd + " time out!") time.sleep(0.1) p.stdout.close() tmpfile = open("tmp", "r+") # 打开文件 contents = tmpfile.readlines() for line in contents: #for log logger.print(line.strip('\n')) for line in contents: regroup = re.search(r'Contract Address:(([0-9]|[a-z]|[A-Z])*)', line) if regroup: deploy_contract_addr = regroup.group(1) regroup = re.search(r'TxHash:(([0-9]|[a-z]|[A-Z])*)', line) if regroup: deploy_contract_txhash = regroup.group(1) if deploy_contract_addr and deploy_contract_txhash: break tmpfile.close() nodeapi.wait_tx_result(deploy_contract_txhash) return (deploy_contract_addr, deploy_contract_txhash) except Exception as e: print(e) return (None, None)
def test_01_dumpprivkey(self): try: result = API.rpc().dumpprivkey( Config.NODES[0]["wallet"].account().address()) self.ASSERT(result is "", "privkey not match") except AssertError as e: logger.error(e.msg) except Exception as e: logger.error(traceback.format_exc())
def check_connected_nodes(self): logger.info("----------------------------------") logger.info("start checking connected node count\n") connected_node_count = get_connected_nodes() if connected_node_count != len(Config.NODES) - 1: logger.error( "connected node counts : %d, config node counts : %d" % (connected_node_count, len(Config.NODES) - 1)) logger.info("checking connected node count OK") logger.info("----------------------------------\n\n")
def ws_heartbeat_thread(self, heartbeat_gap=5): while True: time.sleep(heartbeat_gap) try: if self.terminated: raise TestError("Error") self.LONG_LIVE_WS.send( json.dumps( Task(Config.BASEAPI_PATH + "/ws/heartbeat.json").data()["REQUEST"])) except Exception as e: logger.error(str(e.args[0])) return False
def con_rpc(ip, request): try: con_url = "" if ip: con_url = "http://" + ip + ":20336/jsonrpc" else: con_url = Config.RPC_URL response = requests.post(con_url, data=json.dumps(request), headers=Config.RPC_HEADERS, timeout=10) return response.json() except Exception as e: logger.error("con_rpc:" + str(e.args[0])) raise TestError(54001)
def check_tools(self): logger.info("----------------------------------") logger.info("start checking all nodes tools\n") for i in range(self.nodecounts): logger.info("checking node " + str(i + 1) + " tools......") response = API.node().check_xmode_tools(i) if isinstance(response["result"], str) and "doesnot exists" in response["result"]: logger.error(response["result"]) logger.info("checking node " + str(i + 1) + " tools OK\n") logger.info("checking all nodes tools OK") logger.info("----------------------------------\n\n")
def con_test_service(ip, request): try: con_url = "" if ip: con_url = "http://" + ip + ":23635/jsonrpc" else: con_url = "http://127.0.0.1:23635/jsonrpc" response = requests.post(con_url, data=json.dumps(request), headers=Config.RPC_HEADERS, timeout=10) return response.json() except Exception as e: logger.error("con_test_service:" + str(e.args[0])) raise TestError(54005)
def con_ws(ip, request): try: url = "" if ip: url = "ws://" + ip + ":20335" else: url = Config.WS_URL ws = create_connection(url) ws.send(json.dumps(request)) response = ws.recv() ws.close() return json.loads(response) except Exception as e: logger.error("con_ws:" + str(e.args[0])) raise TestError(54003)
def sftp_transfer(self, _from, _to, remotenode, op="get"): # on local host # if _node_index == 0: # cmd = "cp -rf " + _from + " " + _to # os.system(cmd) # return # private_key = paramiko.RSAKey.from_private_key_file("../../resource/id_rsa", "367wxd") transport = paramiko.Transport((Config.NODES[remotenode]["ip"], 22)) transport.connect(username=Config.NODES[remotenode]["sshuser"], password=Config.NODES[remotenode]["sshpwd"]) sftp = paramiko.SFTPClient.from_transport(transport) if op == "put": sftp.put(_from, _to) elif op == "get": sftp.get(_from, _to) else: logger.error("operation not supported") transport.close()
def con_rpc(ip, request): try: con_url = "" if ip: con_url = "http://" + ip + "/jsonrpc" else: con_url = Config.RPC_URL response = requests.post(con_url, data=json.dumps(request).replace( "\"num#!#start-", "").replace("-num#!#end\"", ""), headers=Config.RPC_HEADERS, timeout=10) return response.json() except Exception as e: logger.error("con_rpc:" + str(e.args[0])) raise RuntimeError(54001)
def check_abi(self): logger.info("----------------------------------") logger.info("start checking all nodes abi\n") for i in range(self.nodecounts): logger.info("checking node " + str(i + 1) + " abi......") response = API.node().get_version_abi(i) if "doesnot exists" in response["result"] or (response["result"] != self.abi_md5): logger.error("node " + str(i + 1) + " abi version error or not exists") logger.info("start transfer abi from node 1 to node " + str(i + 1)) sftp_transfer_dir(self.abi_source_path, self.abi_path, i, "put") logger.info("transfer abi OK ") logger.info("checking node " + str(i + 1) + " abi OK\n") logger.info("checking all nodes abi OK") logger.info("----------------------------------\n\n")
def check_test_config(self): logger.info("----------------------------------") logger.info("start checking all nodes test config\n") for i in range(self.nodecounts): logger.info("checking node " + str(i + 1) + " test config......") response = API.node().get_version_test_config(i) if "doesnot exists" in response["result"] or ( response["result"] != self.test_config_md5): logger.error("node " + str(i + 1) + " test config version error or not exists") logger.info("start transfer test config from node 1 to node " + str(i + 1)) sftp_transfer(self.test_config_source_path, self.test_config_path, i, "put") logger.info("transfer test config OK ") logger.info("checking node " + str(i + 1) + " test config OK\n") logger.info("checking all nodes test config OK") logger.info("----------------------------------\n\n")
def check_self_wallets(self): logger.info("----------------------------------") logger.info("start checking self wallets\n") # check wallet amount files = os.listdir(self.wallet_source_path) files.sort() if len(files) != len(Config.NODES): logger.error( "wallets number incorrect, wallets : [%d] config : [%d]" % (len(files), len(Config.NODES))) address = [] pubkey = [] with open(self.onto_config_source_path) as f: config_json = json.load(f) for _file in files: with open(os.path.join(self.wallet_source_path, _file)) as f: wallet_json = json.load(f) address.append(wallet_json["accounts"][0]["address"]) pubkey.append(wallet_json["accounts"][0]["publicKey"]) for nd in config_json["VBFT"]["peers"]: if not nd["address"] in address: logger.error("wallet address %s not in onto config" % nd["address"]) if not nd["peerPubkey"] in pubkey: logger.error("wallet pubkey %s not in onto config" % nd["peerPubkey"]) logger.info("checking self wallets OK") logger.info("----------------------------------\n\n")
def check_sigsvr(self): logger.info("----------------------------------") logger.info("start checking all nodes sigsvr\n") for i in range(self.nodecounts): logger.info("checking node " + str(i + 1) + " sigsvr......") response = API.node().get_version_sigsvr(i) if "doesnot exists" in response["result"] or ( response["result"]["md5"] != self.sigsvr_md5): logger.error("node " + str(i + 1) + " sigsvr version error or not exists") logger.info("start transfer sigsvr from node 1 to node " + str(i + 1)) sftp_transfer(self.sigsvr_source_path, self.sigsvr_path, i, "put") logger.info("transfer sigsvr OK ") API.node().check_xmode_sigsvr(i) logger.info("checking node " + str(i + 1) + " sigsvr OK\n") logger.info("checking all nodes sigsvr OK") logger.info("----------------------------------\n\n")
def check_wallet(self): logger.info("----------------------------------") logger.info("start checking all nodes wallets\n") for i in range(self.nodecounts): logger.info("checking node " + str(i + 1) + " wallet......") response = API.node().get_version_wallet(i) if "doesnot exists" in response["result"] or ( response["result"] != self.wallet_correct_md5[i]): logger.error("node " + str(i + 1) + " wallet version error or not exists") logger.info("start transfer wallet from node 1 to node " + str(i + 1)) wallet_index = "0" + str(i) if i < 10 else str(i) sftp_transfer( self.wallet_source_path + "/wallet" + wallet_index + ".dat", self.wallet_path, i, "put") logger.info("transfer wallet OK ") logger.info("checking node " + str(i + 1) + " wallet OK\n") logger.info("checking all nodes wallets OK") logger.info("----------------------------------\n\n")
def check_ontology(self): logger.info("----------------------------------") logger.info("start checking all nodes ontology\n") for i in range(self.nodecounts): logger.info("checking node " + str(i + 1) + " ontology......") response = API.node().get_version_ontology(i) if "doesnot exists" in response["result"] or ( response["result"]["md5"] != self.ontology_correct_md5): logger.error("node " + str(i + 1) + " ontology version error or not exists") logger.info("start transfer ontology from node 1 to node " + str(i + 1)) sftp_transfer(self.ontology_source_path, self.node_path, i, "put") logger.info("transfer ontology OK ") API.node().check_xmode_ontology(i) logger.info("checking node " + str(i + 1) + " ontology OK\n") logger.info("checking all nodes ontology OK") logger.info("----------------------------------\n\n")
def test_19_getvalidators(self): try: result = API.rpc().getvalidators() self.ASSERT(result, "") except AssertError as e: logger.error(e.msg) except RPCError as e: logger.error(e.msg) self.ASSERT(True, "") except Exception as e: logger.error(traceback.format_exc())
def test_21_getwalletheight(self): try: result = API.rpc().getwalletheight() self.ASSERT(result, "") except AssertError as e: logger.error(e.msg) except RPCError as e: logger.error(e.msg) self.ASSERT(True, "") except Exception as e: logger.error(traceback.format_exc())
def test_23_invokefunction(self): try: result = API.rpc().invokefunction("", "function", []) self.ASSERT(result, "") except AssertError as e: logger.error(e.msg) except RPCError as e: logger.error(e.msg) self.ASSERT(True, "") except Exception as e: logger.error(traceback.format_exc())
def test_25_listaddress(self): try: result = API.rpc().listaddress() self.ASSERT(result, "") except AssertError as e: logger.error(e.msg) except RPCError as e: logger.error(e.msg) self.ASSERT(True, "") except Exception as e: logger.error(traceback.format_exc())
def test_29_sendmany(self): try: result = API.rpc().sendmany([]) self.ASSERT(result, "") except AssertError as e: logger.error(e.msg) except RPCError as e: logger.error(e.msg) self.ASSERT(True, "") except Exception as e: logger.error(traceback.format_exc())
def test_05_getbestblockhash(self): try: result = API.rpc().getbestblockhash() self.ASSERT(result, "") except AssertError as e: logger.error(e.msg) except RPCError as e: logger.error(e.msg) self.ASSERT(True, "") except Exception as e: logger.error(traceback.format_exc())