def deploy_supervisor(self, node):
"""
部署supervisor
:param node:
:return:
"""
tmp_dir = gen_node_tmp(self.sup_tmp, node["host"], str(node["port"]))
if not os.path.exists(tmp_dir):
os.makedirs(tmp_dir)
tmp = os.path.join(tmp_dir, "supervisord.conf")
self.update_conf(node, self.sup_template, tmp)
ssh, sftp, t = connect_linux(node["host"], node["username"],
node["password"], node["sshport"])
self.run_ssh(ssh, "mkdir -p ./tmp")
sftp.put(tmp, "./tmp/supervisord.conf")
supervisor_pid_str = self.run_ssh(
ssh, "ps -ef|grep supervisord|grep -v grep|awk {'print $2'}")
if len(supervisor_pid_str) > 0:
self.judge_restart_supervisor(ssh, supervisor_pid_str, node)
else:
self.run_ssh(ssh, "sudo -S -p '' apt update", node["password"])
self.run_ssh(ssh, "sudo -S -p '' apt install -y supervisor",
node["password"])
self.run_ssh(
ssh,
"sudo -S -p '' cp ./tmp/supervisord.conf /etc/supervisor/",
node["password"])
supervisor_pid_str = self.run_ssh(
ssh, "ps -ef|grep supervisord|grep -v grep|awk {'print $2'}")
if len(supervisor_pid_str) > 0:
self.judge_restart_supervisor(ssh, supervisor_pid_str, node)
else:
self.run_ssh(ssh, "sudo -S -p '' /etc/init.d/supervisor start",
node["password"])
t.close()
def test_platon_versions(self):
collusion_list, _ = get_node_list(self.node_yml)
node = collusion_list[0]
ssh, sftp, t = connect_linux(node['host'],
username=node['username'],
password=node['password'])
cmd_list = run_ssh(
ssh, "{}/node-{}/platon version".format(conf.DEPLOY_PATH,
node["port"]))
versions = conf.VERSION
assert versions in cmd_list[1], "版本号不正确"
def __init__(self, server_conf, cfg: TestConfig):
self.cfg = cfg
self.host = server_conf["host"]
self.username = server_conf["username"]
self.password = server_conf["password"]
self.ssh_port = server_conf.get("sshport", 22)
self.ssh, self.sftp, self.t = connect_linux(self.host, self.username,
self.password,
self.ssh_port)
self.remote_supervisor_conf = "{}/supervisord.conf".format(
self.cfg.remote_supervisor_tmp)
def boom(self, nodedict):
"""
关闭机器所有platon进程
:param nodedict:
:return:
"""
ip = nodedict.get('host')
sshport = nodedict.get("sshport", 22)
username = nodedict.get('username')
password = nodedict.get('password')
ssh, _, t = connect_linux(ip, username, password, sshport)
self.run_ssh(ssh, "killall -9 platon")
t.close()
def start_node(self,
nodedict,
genesis_file,
static_node_file,
is_init=True,
clean=False):
"""
启动节点
:param nodedict: 节点信息
:param genesis_file: genesis.json文件路径
:param static_node_file: 共识节点互连文件
:param is_init: 是否需要初始化，初始化会删除原platon部署目录的所有数据
:param clean: 是否删除platon部署目录的数据，is_init=True时，该参数无效
:return:
"""
ip = nodedict['host']
port = nodedict.get("port", "16789")
rpcport = nodedict.get("rpcport", "6789")
sshport = nodedict.get("sshport", 22)
username = nodedict["username"]
password = nodedict["password"]
mpcactor = nodedict.get("mpcactor", None)
vcactor = nodedict.get("vcactor", None)
ppos = nodedict.get("ppos", None)
url = nodedict["url"]
ssh, sftp, t = connect_linux(ip, username, password, sshport)
if clean or is_init:
self.clean_blockchain(ssh, port, password)
self.clean_log(ssh, port)
self.upload_platon(ssh, sftp, port)
if is_init:
sftp.put(conf.SPLIT_LOG_SCRIPT,
"{}/node-{}/split_log.py".format(self.deploy_path, port))
if genesis_file is None:
raise Exception("需要初始化时，genesis_file不能为空")
self.upload_genesis_json(sftp, port, genesis_file)
_ = self.init(ssh, port=port)
self.upload_cbft_json(sftp, port)
if static_node_file:
self.upload_static_json(sftp, port, static_node_file)
nodekey = nodedict["nodekey"]
self.upload_nodekey(ssh, sftp, nodekey, ip, port)
self.upload_keystore(ssh, sftp, port)
self.start(ssh,
url,
port=port,
rpcport=rpcport,
cmd=nodedict.get("cmd", None),
mpcactor=mpcactor,
vcactor=vcactor)
t.close()
def kill(self, nodedict):
"""
使用supervisor关闭platon进程
:param nodedict:
:param value:
:param wait_time:
:return:
"""
ip = nodedict['host']
username = nodedict['username']
password = nodedict['password']
sshport = nodedict.get('sshport', 22)
ssh, _, t = connect_linux(ip, username, password, sshport)
self.run_ssh(ssh,
"supervisorctl stop node-{}".format(nodedict["port"]))
t.close()
def update_node(self, node):
"""
根据节点信息更新节点，替换二进制文件
:param node: 节点信息
:return:
"""
ip = node['host']
port = str(node.get("port", "16789"))
username = node["username"]
password = node["password"]
sshport = node.get("sshport", 22)
ssh, sftp, t = connect_linux(ip, username, password, sshport)
self.upload_platon(ssh, sftp, port)
node_name = "node-" + str(port)
self.run_ssh(ssh, "supervisorctl restart {}".format(node_name))
t.close()
def restart(self, node):
"""
重启一个节点
:param node: 节点信息
:return:
"""
ip = node['host']
port = str(node.get("port", "16789"))
username = node["username"]
password = node["password"]
sshport = node.get("sshport", 22)
ssh, sftp, t = connect_linux(ip, username, password, sshport)
node_name = "node-" + str(port)
self.run_ssh(ssh, "supervisorctl stop {}".format(node_name))
self.run_ssh(ssh, "supervisorctl start {}".format(node_name))
t.close()
def stop(self, nodedict):
"""
以kill -9的方式停止一个节点，关闭后节点无法重启，只能重新部署链
:param nodedict:
:return:
"""
ip = nodedict['host']
sshport = nodedict.get("sshport", 22)
username = nodedict['username']
password = nodedict['password']
port = nodedict.get("port", "6789")
ssh, _, t = connect_linux(ip, username, password, sshport)
self.run_ssh(
ssh,
"ps -ef|grep platon|grep %s|grep -v grep|awk {'print $2'}|xargs kill -9"
% port)
t.close()
def install_dependency(self, nodedict, file=conf.MPCLIB):
"""
配置服务器依赖
:param nodedict:
:param file:
:return:
"""
global lock
lock.acquire()
try:
ssh, sftp, t = connect_linux(nodedict["host"],
nodedict["username"],
nodedict["password"],
nodedict["sshport"])
except Exception as e:
raise e
self.run_ssh(ssh, "sudo -S -p '' ntpdate 0.centos.pool.ntp.org",
nodedict["password"])
pwd_list = self.run_ssh(ssh, "pwd")
pwd = pwd_list[0].strip("\r\n")
cmd = r"sudo -S -p '' sed -i '$a export LD_LIBRARY_PATH={}/mpclib' /etc/profile".format(
pwd)
is_have_mpclib = self.run_ssh(ssh, 'ls|grep "mpclib"')
# self.run_ssh(
# ssh,
# "sudo -S -p '' apt-get install libgmpxx4ldbl libgmp-dev libprocps4-dev",
# nodedict["password"])
if not is_have_mpclib:
sftp.put(file, os.path.basename(file))
self.run_ssh(ssh, "tar -zxvf ./{}".format(os.path.basename(file)))
self.run_ssh(ssh, "mv ./platon-mpc-ubuntu-amd64-0.5.0/ ./mpclib")
self.run_ssh(ssh, cmd, nodedict["password"])
self.run_ssh(ssh, "rm -rf ./{}".format(os.path.basename(file)))
# self.run_ssh(
# ssh, "sudo -S -p '' apt-get install libboost-all-dev -y", nodedict["password"])
# self.run_ssh(
# ssh, "sudo -S -p '' apt-get install llvm-6.0-dev llvm-6.0 libclang-6.0-dev -y", nodedict["password"])
self.run_ssh(
ssh,
"sudo -S -p '' apt-get install libgmpxx4ldbl libgmp-dev libprocps4-dev",
nodedict["password"])
t.close()
lock.release()
def setup_class(self):
self.auto.start_all_node(self.node_yml,
genesis_file=conf.GENESIS_TMP,
static_node_file=conf.STATIC_NODE_FILE)
# 等一下，同步块高
collusion, _ = get_node_list(conf.NODE_YML)
collusion_w3 = connect_web3(collusion[0]["url"])
collusion_block = collusion_w3.eth.blockNumber
_, nocollusion = get_node_list(self.node_yml)
self.url = nocollusion[0]['url']
self.ip = nocollusion[0]["host"]
self.wt = PlatonContractTransaction(self.url)
self.password = conf.PASSWORD
nocollusion_block = self.wt.eth.blockNumber
if collusion_block - nocollusion_block >= 100:
time.sleep(20)
elif 100 > collusion_block - nocollusion_block >= 50:
time.sleep(10)
else:
time.sleep(5)
addrress = self.wt.w3.toChecksumAddress(conf.ADDRESS)
self.wt.w3.personal.unlockAccount(addrress, self.password, 999999)
"""部署合约"""
resp = self.wt.contract_deploy(
get_byte_code(abspath('./data/contract/vccMain.wasm')),
get_abi_bytes(abspath(r'./data/contract/vccMain.cpp.abi.json')),
addrress)
result = self.wt.eth.waitForTransactionReceipt(resp)
self.contract_address = result['contractAddress']
log.info(self.contract_address)
if len(self.wt.eth.getCode(self.contract_address)) < 10:
raise Exception("合约部署失败")
node = nocollusion[0]
ssh, sftp, t = connect_linux(node['host'],
username=node['username'],
password=node['password'])
pwd_list = run_ssh(ssh, "pwd")
pwd = pwd_list[0].strip("\r\n")
account = 'UTC--2018-10-04T09-02-39.439063439Z--493301712671ada506ba6ca7891f436d29185821'
self.wallet_path = '{}/{}/data16789/keystore/{}'.format(
pwd, conf.DEPLOY_PATH, account)
cmd = '''nohup java -jar ./vc_tool/vctool-1.0.jar > ./vc_tool/nohup.out 2>&1 &'''
run_ssh(ssh, cmd)
self.get_url = 'http://{}:8112/test/getResult'.format(self.ip)
def supervisor_deploy_platon(self,
node,
genesis_file,
static_node_file,
is_init=True,
clean=False):
"""
使用supervisor部署platon，灵活部署
:param node:
:param genesis_file:
:param static_node_file:
:param is_init:
:param clean:
:return:
"""
self.gen_deploy_conf(node)
ip = node['host']
port = str(node.get("port", "16789"))
username = node["username"]
password = node["password"]
sshport = node.get('sshport', 22)
ssh, sftp, t = connect_linux(ip, username, password, sshport)
node_name = "node-" + str(port)
if clean or is_init:
self.clean_blockchain(ssh, port, password)
self.clean_log(ssh, port)
self.upload_platon(ssh, sftp, port)
if is_init:
if genesis_file is None:
raise Exception("需要初始化时，genesis_file不能为空")
self.upload_genesis_json(sftp, port, genesis_file)
_ = self.init(ssh, port=port)
self.upload_cbft_json(sftp, port)
if static_node_file:
self.upload_static_json(sftp, port, static_node_file)
nodekey = node["nodekey"]
self.upload_nodekey(ssh, sftp, nodekey, ip, port)
self.upload_keystore(ssh, sftp, port)
self.start_node_conf(ssh, sftp, port, node, node_name)
t.close()
def deploy_default(self, node):
"""
使用默认参数部署节点（不初始化）
:param node: 节点信息
:return:
"""
self.gen_deploy_conf(node)
ip = node['host']
port = str(node.get("port", "16789"))
username = node["username"]
password = node["password"]
sshport = node.get("sshport", 22)
ssh, sftp, t = connect_linux(ip, username, password, sshport)
node_name = "node-" + str(port)
self.clean_blockchain(ssh, port, password)
self.clean_log(ssh, port)
self.upload_platon(ssh, sftp, port)
nodekey = node["nodekey"]
self.upload_nodekey(ssh, sftp, nodekey, ip, port)
self.upload_keystore(ssh, sftp, port)
self.start_node_conf(ssh, sftp, port, node, node_name)
t.close()
def kill(self, nodedict):
"""
以kill方式关闭一个节点,关闭后，节点还能被重启
:param nodedict: 连接对象
:return:
"""
ip = nodedict['host']
sshport = nodedict.get("sshport", 22)
username = nodedict['username']
password = nodedict['password']
port = nodedict.get("port", "16789")
ssh, _, t = connect_linux(ip, username, password, sshport)
self.run_ssh(
ssh,
"ps -ef|grep platon|grep %s|grep -v grep|awk {'print $2'}|xargs kill"
% port)
time.sleep(5)
result = self.run_ssh(
ssh,
"ps -ef|grep platon|grep %s|grep -v grep|awk {'print $2'}" % port)
t.close()
if result:
raise Exception("进程关闭失败")
def __init__(self, node_conf, cfg: TestConfig, chain_id):
self.cfg = cfg
# node identity parameter
self.blspubkey = node_conf["blspubkey"]
self.blsprikey = node_conf["blsprikey"]
self.node_id = node_conf["id"]
self.nodekey = node_conf["nodekey"]
# node startup necessary parameters
self.p2p_port = str(node_conf["port"])
self.rpc_port = str(node_conf["rpcport"])
# node starts non essential parameters
self.wsport = node_conf.get("wsport")
self.wsurl = node_conf.get("wsurl")
self.pprofport = node_conf.get("pprofport")
self.fail_point = node_conf.get("fail_point")
# node server information
self.host = node_conf["host"]
self.username = node_conf["username"]
self.password = node_conf["password"]
self.ssh_port = node_conf.get("sshport", 22)
if self.cfg.can_deploy:
self.ssh, self.sftp, self.t = connect_linux(self.host, self.username, self.password, self.ssh_port)
else:
self.ssh, self.sftp, self.t = mock_connect_linux()
# node identification information
self.url = node_conf["url"]
self.node_name = "node-" + self.p2p_port
self.node_mark = self.host + ":" + self.p2p_port
# node remote directory information
if os.path.isabs(self.cfg.deploy_path):
self.remote_node_path = "{}/{}".format(self.cfg.deploy_path, self.node_name)
else:
self.remote_node_path = "{}/{}/{}".format(self.pwd, self.cfg.deploy_path, self.node_name)
self.remote_log_dir = '{}/log'.format(self.remote_node_path)
self.remote_bin_file = self.remote_node_path + "/platon"
self.remote_genesis_file = self.remote_node_path + "/genesis.json"
self.remote_config_file = self.remote_node_path + "/config.json"
self.remote_data_dir = self.remote_node_path + "/data"
self.remote_blskey_file = '{}/blskey'.format(self.remote_data_dir)
self.remote_nodekey_file = '{}/nodekey'.format(self.remote_data_dir)
self.remote_keystore_dir = '{}/keystore'.format(self.remote_data_dir)
self.remote_static_nodes_file = '{}/static-nodes.json'.format(self.remote_data_dir)
self.remote_db_dir = '{}/platon'.format(self.remote_data_dir)
self.remote_supervisor_node_file = '{}/{}.conf'.format(self.cfg.remote_supervisor_tmp, self.node_name)
# RPC connection
self.__is_connected = False
self.__rpc = None
self.__is_connected_ppos = False
self.__ppos = None
self.__is_connected_pip = False
self.__pip = None
self.__is_ws_connected = False
self.__ws_rpc = None
# remote directory
self.make_remote_dir()
# node local tmp
self.local_node_tmp = self.gen_node_tmp()
# self.genesis_config = LoadFile(self.cfg.genesis_file).get_data()
self.chain_id = chain_id
def gen_deploy_conf(self, node):
"""
生成supervisor部署platon的配置
:param node:
:return:
"""
port = str(node["port"])
node_name = "node-" + port
ssh, sftp, t = connect_linux(node["host"], node["username"],
node["password"], node["sshport"])
pwd_list = self.run_ssh(ssh, "pwd")
pwd = pwd_list[0].strip("\r\n")
with open(
gen_node_tmp(self.sup_tmp, node["host"], port) + "/" +
node_name + ".conf", "w") as fp:
fp.write("[program:" + node_name + "]\n")
if not os.path.isabs(self.deploy_path):
cmd = "{}/{}/{}/platon --identity platon --datadir".format(
pwd, self.deploy_path, node_name)
cmd = cmd + \
" {}/{}/{}/data --port ".format(pwd,
self.deploy_path, node_name) + port
else:
cmd = "{}/{}/platon --identity platon --datadir".format(
self.deploy_path, node_name)
cmd = cmd + \
" {}/{}/data --port ".format(self.deploy_path,
node_name) + port
cmd = cmd + " --syncmode '{}'".format(self.syncmode)
if self.net_type:
cmd = cmd + " --" + self.net_type
if node.get("mpcactor", None):
cmd = cmd + \
" --mpc --mpc.actor {}".format(node.get("mpcactor"))
if node.get("vcactor", None):
cmd = cmd + \
" --vc --vc.actor {} --vc.password 88888888".format(
node.get("vcactor"))
cmd = cmd + "--config {}".format(conf.PPOS_CONFIG_PATH)
cmd = cmd + " --debug --verbosity 4"
# cmd = cmd + " --pprof --pprofaddr 0.0.0.0 --pprofport " + \
# node["pprof_port"]
if parse.splittype(node["url"])[0] == "ws":
cmd = cmd + " --ws --wsorigins '*' --wsaddr 0.0.0.0 --wsport " + \
str(node["rpcport"])
cmd = cmd + " --wsapi eth,debug,personal,admin,net,web3"
else:
cmd = cmd + " --rpc --rpcaddr 0.0.0.0 --rpcport " + str(
node["rpcport"])
cmd = cmd + " --rpcapi platon,debug,personal,admin,net,web3"
cmd = cmd + " --txpool.nolocals"
if self.is_metrics:
cmd = cmd + " --metrics"
cmd = cmd + " --metrics.influxdb --metrics.influxdb.endpoint http://10.10.8.16:8086"
cmd = cmd + " --metrics.influxdb.database platon"
cmd = cmd + \
" --metrics.influxdb.host.tag {}:{}".format(
node["host"], str(node["port"]))
if os.path.isabs(self.deploy_path):
cmd = cmd + " --gcmode archive --nodekey " + \
node["path"] + \
"{}/{}/data/nodekey".format(self.deploy_path, node_name)
else:
cmd = cmd + " --gcmode archive --nodekey " + \
"{}/{}/{}/data/nodekey".format(pwd,
self.deploy_path, node_name)
fp.write("command=" + cmd + "\n")
fp.write("environment=LD_LIBRARY_PATH={}/mpclib\n".format(pwd))
fp.write("numprocs=1\n")
fp.write("autostart=false\n")
fp.write("startsecs=3\n")
fp.write("startretries=3\n")
fp.write("autorestart=unexpected\n")
fp.write("exitcode=0\n")
fp.write("stopsignal=TERM\n")
fp.write("stopwaitsecs=10\n")
fp.write("redirect_stderr=true\n")
if os.path.isabs(self.deploy_path):
fp.write("stdout_logfile={}/{}/log/platon.log\n".format(
self.deploy_path, node_name))
else:
fp.write("stdout_logfile={}/{}/{}/log/platon.log\n".format(
pwd, self.deploy_path, node_name))
fp.write("stdout_logfile_maxbytes=200MB\n")
fp.write("stdout_logfile_backups=20\n")
t.close()
