def ls_host(hosts):
"""[show in host_ip which port used (published fisco-bcos) ]
Arguments:
hosts {[string]} -- [host_ip]
"""
am = AllMeta()
ns = Names()
for host in hosts:
consoler.info(' => host is %s', host)
if not utils.valid_ip(host):
consoler.info(' \t => Invalid host ip, host is %s.', host)
continue
metas = get_meta_ports_by_host(host, am)
if len(metas) == 0:
consoler.info(' \t => No chain published to this host.')
continue
for meta in metas:
consoler.info(
' \t => chain id :%s chain name : %s published version : %s',
meta.get_chain_id(), ns.get_name(meta.get_chain_id()),
meta.get_chain_version())
nodes = meta.get_host_nodes(host)
for node in nodes:
consoler.info(
' \t\t %s, rpc_port:%s, p2p_port:%s, channel_port:%s',
node.get_node(), str(node.get_rpc()), str(node.get_p2p()),
str(node.get_channel()))
def check_chain(chain):
"""[Check if the nodes is running normally.]
Arguments:
chain {[list]} -- [get chain_id:host_ip from command Line]
"""
if chain[0] == 'all':
dir = data.meta_dir_base()
if os.path.exists(dir):
for chain_id in os.listdir(dir):
check_server(chain_id)
else:
consoler.info(' No published chain exist, do nothing.')
else:
for i in range(len(chain)):
chain_get = chain[i].split(':')
if len(chain_get) == 1:
if utils.valid_chain_id(chain_get[0]):
check_server(chain_get[0])
else:
consoler.info(' skip, invalid chain_id, chain_id is %s', chain_get[0])
elif len(chain_get) == 2:
if utils.valid_chain_id(chain_get[0]):
if utils.valid_ip(chain_get[1]):
ansible.check_module(chain_get[1], ansible.get_dir() + '/' + chain_get[0])
else:
consoler.info(' skip, invalid host, chain_id is %s, host is %s', chain_get[0], chain_get[1])
else:
consoler.info(' skip, invalid chain_id, chain_id is %s, host is %s', chain_get[0], chain_get[1])
else:
consoler.info(' skip, invalid format, not chain_id:host, input %s', chain_get)
def do_cmd(dst, cmd):
"""do cmd on remote server, dst can be one server, one chain or all server
Arguments:
dst {string} -- host ip or chain id or 'all'
cmd {string} -- shell cmd or shell file
"""
if dst == 'all':
ansible.cmd_module('all', cmd)
elif utils.valid_chain_id(dst):
mm = Meta(dst)
if not mm.exist():
consoler.error(
' \033[1;31m chain is not published, can not cmd action, chain_id is %s \033[0m',
dst)
else:
consoler.info(' => do cmd, chain id is %s', dst)
for k in mm.get_nodes().keys():
logger.debug('host ip is ' + k)
ansible.cmd_module(k, cmd)
elif utils.valid_ip(dst):
ansible.cmd_module(dst, cmd)
else:
consoler.error(
' \033[1;31m invalid docmd dst, dst is %s, dst should be invalid chain_id or invali host ip or \'all\'. \033[0m',
dst)
def init_ansible(hosts_conf, add_opr=False):
try:
if not os.path.exists(hosts_conf):
raise MCError('hosts_conf not exisits! ')
if add_opr:
src = '/etc/ansible/hosts'
dst = '/etc/ansible/hosts.bak'
if not os.path.exists(src):
raise MCError('/etc/ansible/hosts not exisits! ')
os.rename(src, dst)
f = open(src, 'w')
f.close()
for line in open(hosts_conf):
line = line.strip()
host_value = line.split()
if len(host_value) != 4:
raise Exception('hosts_conf type error ,host_line -> %s',
host_value)
user = host_value[0]
ip = host_value[1]
port = host_value[2]
passwd = host_value[3]
if not utils.valid_string(user):
raise Exception(
'user type error ,user -> %s, host_line -> %s' %
(user, host_value))
if not utils.valid_ip(ip):
raise Exception('ip type error ,ip -> %s, host_line -> %s' %
(ip, host_value))
if not utils.valid_port(int(port)):
raise Exception(
'port type error ,port -> %s, host_line -> %s' %
(port, host_value))
if not utils.valid_string(passwd):
raise Exception(
'passwd type error ,passwd -> %s, host_line -> %s' %
(passwd, host_value))
(status,
result) = utils.getstatusoutput('bash ' + path.get_path() +
'/scripts/ansible_init.sh' + ' ' +
user + ' ' + ip + ' ' + port +
' ' + passwd)
if status != 0:
logger.warn(
' ansible_init failed! status is %d, output is %s.',
status, result)
raise MCError(
'ansible_init failed! status is %d, output is %s.' %
(status, result))
result = []
result.append(ip)
opr_tools.telnet_ansible(result)
logger.info(' ansible_init success! status is %d, output is %s',
status, result)
except MCError as me:
consoler.error(' \033[1;31m %s \033[0m', me)
except Exception as e:
consoler.error(
' \033[1;31m ansible_init failed! excepion is %s.\033[0m', e)
def do_parser(self):
l = self.node_desc.split()
if len(l) < 3:
raise Exception(" node_desc invalid format ", self.node_desc)
if not utils.valid_ip(l[0]):
raise Exception(" node_desc invalid format invalid host_ip ", l[0])
if not utils.valid_ip(l[1]):
raise Exception(" node_desc invalid format invalid p2p_ip ", l[1])
if int(l[2]) <= 0:
raise Exception(" node_desc invalid format node_num lt 0 ", l[2])
self.host_ip = l[0]
self.p2p_ip = l[1]
self.node_num = int(l[2])
logger.info(' cfg parser host ip is %s, p2p ip is %s, node_num is %d.', self.host_ip, self.p2p_ip, self.node_num)
def publish_server(chain_id, chain_version, force=False):
"""publish one chain.
Arguments:
chain_id {string} -- chain id.
chain_version {string} -- chain version.
force {bool}
"""
chain = Chain(chain_id, chain_version)
dir = chain.data_dir()
if not os.path.isdir(dir):
consoler.info(
' No build version exist for chain_id:%s chain_version:%s, do nothing.', chain_id, chain_version)
logger.warn(
' No build version exist for chain_id:%s chain_version:%s, do nothing.', chain_id, chain_version)
return
mm = meta.Meta(chain_id)
if force:
# force is set, publish this chain again.
mm.clear()
mm.set_chain_version(chain_version)
else:
if mm.exist():
if chain_version != mm.get_chain_version():
consoler.error(
' \033[1;31m chain %s already publish %s version, if you want publish annother version, --force/-f need to be set.\033[0m ', chain_id, mm.get_chain_version())
return
else:
mm.set_chain_version(chain_version)
consoler.info(' publish package for chain %s version %s begin.',
chain_id, chain_version)
for host in os.listdir(dir):
if not utils.valid_ip(host):
logger.debug(' skip, not invalid host_ip ' + host)
continue
ret = push_package(dir, host, chain_id, chain_version, mm, force)
if ret:
hp = HostPort(chain_id, chain_version, host)
for node_dir, p in hp.get_ports().items():
logger.debug(' node_dir is %s, port is %s', node_dir, p)
if not mm.host_node_exist(host, node_dir):
mm.append(meta.MetaNode(host, p.get_rpc_port(), p.get_p2p_port(), p.get_channel_port(), node_dir))
consoler.info(' \t push package : %s success.', host)
else:
consoler.error(' \033[1;31m \t push package : %s failed. \033[0m', host)
# record meta info, write meta.json file
mm.write_to_file()
consoler.info(' publish package for chain %s version %s end.', chain_id, chain_version)
def env_check(hosts):
"""[check and confirm the environment normally]
Arguments:
hosts {string} -- host list
"""
if hosts[0] == 'all':
ansible.env_check('all', path.get_path())
else:
for host in hosts:
if utils.valid_ip(host):
ansible.env_check(host, path.get_path())
else:
consoler.log(' skip, not invalid host, host is %s', host)
def stop_chain(chain):
"""[stop nodes]
Arguments:
chain {[list]} -- [get chain_id:host_ip from command Line]
"""
if chain[0] == 'all':
consoler.info('You want to stop all node,are you sure? yes or no? y/n')
consoler.info('Your choice is : ')
choice = sys.stdin.readline().strip('\n')
if ((choice == 'yes') | (choice == 'Yes') | (choice == 'Y') |
(choice == 'y')):
dir = data.meta_dir_base()
if os.path.exists(dir):
for chain_id in os.listdir(dir):
stop_server(chain_id)
else:
consoler.info(' No published chain exist, do nothing.')
else:
consoler.info(' input No, and will do nothing.')
logger.info('refuse stop all node')
else:
for i in range(len(chain)):
chain_get = chain[i].split(':')
if len(chain_get) == 1:
if utils.valid_chain_id(chain_get[0]):
stop_server(chain_get[0])
else:
consoler.info(' skip, invalid chain_id, chain_id is %s',
chain_get[0])
elif len(chain_get) == 2:
if utils.valid_chain_id(chain_get[0]):
if utils.valid_ip(chain_get[1]):
ansible.stop_module(
chain_get[1],
ansible.get_dir() + '/' + chain_get[0])
else:
consoler.info(
' skip, invalid host, chain_id is %s, host is %s',
chain_get[0], chain_get[1])
else:
consoler.info(
' skip, invalid chain_id, chain_id is %s, host is %s',
chain_get[0], chain_get[1])
else:
consoler.info(
' skip, invalid format, not chain_id:host, input %s',
chain_get)
def push_file(host, src, dst):
"""push file to remote server
Arguments:
host {string} -- host ip or chain id or 'all'
src {string} -- file or dir
dst {string} -- dst dir
"""
if not os.path.exists(src):
consoler.error(' \033[1;31m src is not exist, src is %s. \033[0m', src)
return
logger.info(' host is %s, src is %s, dst is %s', host, src, dst)
if host == 'all':
if mkdir_and_push(host, src, dst):
consoler.info(' push %s to %s of all server success.', src, dst)
elif utils.valid_chain_id(host):
consoler.info(' => push %s to %s of chain %s.', src, dst, host)
mm = Meta(host)
if not mm.exist():
consoler.error(
' \033[1;31m chain is not published, can not push file action, chain_id is %s \033[0m',
host)
else:
consoler.info(' => do cmd, chain id is %s', host)
for k in mm.get_nodes().keys():
logger.debug(' host is %s', k)
if mkdir_and_push(k, src, dst):
consoler.info(' \t\t push %s to %s of %s server success.',
src, dst, k)
consoler.info(' => push %s to %s of chain %s end.', src, dst, host)
elif utils.valid_ip(host):
if mkdir_and_push(host, src, dst):
consoler.info(' push %s to %s of %s server success.', src, dst,
host)
else:
consoler.error(
' \033[1;31m invalid push file host, host is %s, dst should be invalid chain_id or invali host ip or \'all\'. \033[0m',
host)
def telnet_ansible(server):
"""[Test ansible operation to all server in operation server]
Arguments:
server {[list]} -- [host ip]
"""
if server[0] == 'all':
server = ['all']
for i in range(len(server)):
if utils.valid_ip(server[i]) or server[i] == 'all':
if ansible.telnet_module(server[i]):
consoler.info(' telnet test success, host is %s.\n', server[i])
else:
consoler.error(
' \033[1;31m telnet test failed, host is %s. \033[0m',
server[i])
else:
consoler.error(
' \033[1;31m Not invalid host, skip, host is %s. \033[0m',
server[i])
def load(self):
self.clear()
if not self.exist():
logger.info('dir not exist, chain_id is %s, chain_version is %s',
self.chain_id, self.chain_version)
return
dir = self.chain.data_dir()
logger.debug(
'load begin, chain_id is %s, chain_version is %s, dir is %s',
self.chain_id, self.chain_version, dir)
for host in os.listdir(dir):
if utils.valid_ip(host):
self.append(host)
logger.debug(' chain id %s, chain version %s, host is %s',
self.chain_id, self.chain_version, host)
else:
logger.debug(
' skip, not invalid host_ip, chain id is %s, chain version is %s, host is %s',
self.chain_id, self.chain_version, host)
logger.info('load end, len is %d', len(self.get_pkg_list()))
def build_config_ini(_data_dir):
"""[-- build create config_ini]
Keyword Arguments:
_meta_dir {[PATH]} -- [input dir] (default: {meta})
_data_dir {[PATH]} -- [output dir] (default: {data})
Raises:
MCError -- [description]
MCError -- [description]
MCError -- [description]
MCError -- [description]
"""
LOGGER.info("build_config_ini start ")
p2p_listen_port = mconf.MchainConf.p2p_listen_port
jsonrpc_listen_port = mconf.MchainConf.jsonrpc_listen_port
channel_listen_port = mconf.MchainConf.channel_listen_port
p2p_ip = mconf.MchainConf.p2p_ip
rpc_ip = mconf.MchainConf.rpc_ip
peers = mconf.MchainConf.peers
meta_dir = '{}/meta'.format(path.get_path())
conf_dir = meta_dir
package_dir = _data_dir
gm_opr = utils.Status.gm_option
group_id = mconf.MchainConf.group_id
utils.file_must_exists('{}/group.{}.genesis'.format(meta_dir, group_id))
if os.path.exists(package_dir):
LOGGER.error(' %s existed, maybe u had created it!', package_dir)
raise MCError(' %s existed, maybe u had created it!' % package_dir)
os.mkdir(package_dir)
default_cfg = configparser.ConfigParser()
if gm_opr:
shutil.copy('{}/tpl/config.ini.gm'.format(path.get_path()),
'{}/.config.ini'.format(conf_dir))
else:
shutil.copy('{}/tpl/config.ini'.format(path.get_path()),
'{}/.config.ini'.format(conf_dir))
try:
with codecs.open('{}/.config.ini'.format(conf_dir),
'r', encoding='utf-8') as config_file:
default_cfg.readfp(config_file)
except Exception as build_exp:
LOGGER.error(
' open config.ini file failed, exception is %s', build_exp)
raise MCError(
' open config.ini file failed, exception is %s' % build_exp)
fin_p2p_ip = []
if not peers:
LOGGER.warning('section peers not existed!')
CONSOLER.warn('section peers not existed!')
else:
for _, peer in enumerate(peers):
fin_p2p_ip.append(peer)
# default_cfg.set("p2p", "node.{}".format(node_id + len(p2p_listen_port)),
# peer)
# with open('{}/.config.ini'.format(conf_dir), 'w') as config_file:
# default_cfg.write(config_file)
# init config.ini & node package
for my_node_index, node_ip in enumerate(p2p_ip):
LOGGER.info("p2p_ip -> %s", node_ip)
try:
if utils.Status.gm_option:
utils.file_must_exists('{}/gmcert_{}_{}.crt'.format(conf_dir,
node_ip,
p2p_listen_port[my_node_index]))
else:
utils.file_must_exists('{}/cert_{}_{}.crt'.format(conf_dir,
node_ip,
p2p_listen_port[my_node_index]))
except Exception as build_exp:
LOGGER.error('%s', build_exp)
raise MCError('%s' % build_exp)
CONSOLER.info(' Generate %s/node_%s_%s ',
package_dir, node_ip, p2p_listen_port[my_node_index])
node_dir = '{}/node_{}_{}'.format(package_dir,
node_ip, p2p_listen_port[my_node_index])
os.mkdir(node_dir)
shutil.copy('{}/tpl/start.sh'.format(path.get_path()),
'{}/start.sh'.format(node_dir))
shutil.copy('{}/tpl/stop.sh'.format(path.get_path()),
'{}/stop.sh'.format(node_dir))
shutil.copy('{}/fisco-bcos'.format(meta_dir),
'{}/fisco-bcos'.format(node_dir))
os.mkdir('{}/conf'.format(node_dir))
try:
# get node cert
shutil.copy('{}/.config.ini'.format(conf_dir),
'{}/config.ini'.format(node_dir))
shutil.copy('{}/group.{}.genesis'.format(conf_dir, group_id),
'{}/conf/group.{}.genesis'.format(node_dir, group_id))
shutil.copy('{}/tpl/group.i.ini'.format(path.get_path()),
'{}/conf/group.{}.ini'.format(node_dir, group_id))
if gm_opr:
get_node_cert('{}/gmcert_{}_{}.crt'.format(meta_dir, node_ip,
p2p_listen_port[my_node_index]),
'{}/conf/gmnode.crt'.format(node_dir))
# get_nodeid('{}/conf/gmnode.crt'.format(node_dir),
# '{}/conf/gmnode.nodeid'.format(node_dir))
shutil.copyfile('{}/gmca.crt'.format(meta_dir),
'{}/conf/gmca.crt'.format(node_dir))
else:
get_node_cert('{}/cert_{}_{}.crt'.format(meta_dir, node_ip,
p2p_listen_port[my_node_index]),
'{}/conf/node.crt'.format(node_dir))
# get_nodeid('{}/conf/node.crt'.format(node_dir),
# '{}/conf/node.nodeid'.format(node_dir))
shutil.copyfile('{}/ca.crt'.format(meta_dir),
'{}/conf/ca.crt'.format(node_dir))
except Exception as build_exp:
LOGGER.error(' get node.crt failed ! exception is %s', build_exp)
utils.delete_data(package_dir)
raise MCError(' get node.crt failed! exception is %s' % build_exp)
node_cfg = configparser.ConfigParser()
try:
with codecs.open('{}/config.ini'.format(node_dir),
'r', encoding='utf-8') as config_file:
node_cfg.readfp(config_file)
except Exception as build_exp:
LOGGER.error(
' open config.ini file failed, exception is %s', build_exp)
utils.delete_data(package_dir)
raise MCError(
' open config.ini file failed, exception is %s' % build_exp)
node_cfg.set("rpc", "listen_ip", rpc_ip[my_node_index])
node_cfg.set("rpc", "channel_listen_port",
channel_listen_port[my_node_index])
node_cfg.set("rpc", "jsonrpc_listen_port",
jsonrpc_listen_port[my_node_index])
# node_cfg.set("p2p", "listen_ip", p2p_ip[my_node_index])
node_cfg.set("p2p", "listen_port", p2p_listen_port[my_node_index])
with open('{}/config.ini'.format(node_dir), 'w') as config_file:
node_cfg.write(config_file)
config_file.close()
# set p2p ip in config.ini
for my_node_index, ip_item in enumerate(p2p_ip):
node_cfg = configparser.ConfigParser()
if not utils.valid_ip(ip_item):
LOGGER.error(
' init config.ini file failed, found ip => %s', ip_item)
utils.delete_data(package_dir)
raise MCError(
' init config.ini file failed, found ip => %s' % ip_item)
node_dir = '{}/node_{}_{}'.format(package_dir,
ip_item, p2p_listen_port[my_node_index])
try:
with codecs.open('{}/config.ini'.format(node_dir),
'r', encoding='utf-8') as config_file:
node_cfg.readfp(config_file)
except Exception as build_exp:
LOGGER.error(
' open config.ini file failed, exception is %s', build_exp)
utils.delete_data(package_dir)
raise MCError(
' open config.ini file failed, exception is %s' % build_exp)
# write p2pip:port into config.ini
for ip_idx, set_item in enumerate(p2p_ip):
fin_p2p_ip.append("{}:{}".format(set_item, p2p_listen_port[ip_idx]))
fin_p2p_ip = list(set(fin_p2p_ip))
for index, p2p_section in enumerate(fin_p2p_ip):
node_cfg.set("p2p", "node.{}".format(index),
'{}'.format(p2p_section))
with open('{}/config.ini'.format(node_dir), 'w') as config_file:
node_cfg.write(config_file)
os.mkdir(package_dir + '/scripts/')
shutil.copy('{}/scripts/install.sh'.format(path.get_path()),
package_dir + '/scripts/')
shutil.copy('{}/scripts/pack.sh'.format(path.get_path()),
package_dir + '/scripts/')
shutil.copy('{}/tpl/start_all.sh'.format(path.get_path()), package_dir)
shutil.copy('{}/tpl/stop_all.sh'.format(path.get_path()), package_dir)
shutil.copytree('{}/scripts/monitor'.format((path.get_path())),
'{}/monitor'.format(package_dir))
LOGGER.info("build_config_ini end!")
def parser(mchain):
"""resolve node_installation.ini
Arguments:
mchain {string} -- path of node_installation.ini
Raises:
MCError -- exception description
"""
LOGGER.info('node_installation.ini is %s', mchain)
# resolve configuration
if not utils.valid_string(mchain):
LOGGER.error(
' node_installation.ini not invalid path, node_installation.ini is %s',
mchain)
raise MCError(
' node_installation.ini not invalid path, node_installation.ini is %s'
% mchain)
# read and parser config file
config_parser = configparser.ConfigParser(allow_no_value=True)
try:
with codecs.open(mchain, 'r', encoding='utf-8') as file_mchain:
config_parser.readfp(file_mchain)
except Exception as ini_exp:
LOGGER.error(
' open node_installation.ini file failed, exception is %s',
ini_exp)
raise MCError(
' open node_installation.ini file failed, exception is %s' %
ini_exp)
for idx in range(0, 128):
node_index = ('node{}'.format(idx))
if config_parser.has_section('group'):
MchainConf.group_id = config_parser.get('group', 'group_id')
else:
LOGGER.error(
' invalid node_installation.ini format, group id is %s',
MchainConf.group_id)
raise MCError(
' invalid node_installation.ini format, group id is %s' %
MchainConf.group_id)
if config_parser.has_section(node_index):
p2p_ip = config_parser.get(node_index, 'p2p_ip')
rpc_ip = config_parser.get(node_index, 'rpc_ip')
if not utils.valid_ip(p2p_ip):
LOGGER.error(
' invalid node_installation.ini format, p2p_ip is %s',
p2p_ip)
raise MCError(
' invalid node_installation.ini format, p2p_ip is %s' %
p2p_ip)
# if rpc_ip == "0.0.0.0" and utils.Status.allow_unsecure_cfg:
if rpc_ip == "0.0.0.0":
LOGGER.warning('Your rpc_ip is %s, this is an unsecurity way',
rpc_ip)
CONSOLER.warning(
' \033[1;31m Your rpc_ip is %s, this is an unsecurity way \033[0m',
rpc_ip)
elif not utils.valid_ip(rpc_ip):
LOGGER.error(
' invalid node_installation.ini format, rpc_ip is %s',
rpc_ip)
raise MCError(
' invalid node_installation.ini format, rpc_ip is %s' %
rpc_ip)
p2p_listen_port = config_parser.get(node_index, 'p2p_listen_port')
jsonrpc_listen_port = config_parser.get(node_index,
'jsonrpc_listen_port')
channel_listen_port = config_parser.get(node_index,
'channel_listen_port')
if not (utils.valid_string(p2p_listen_port)
and utils.valid_string(jsonrpc_listen_port)
and utils.valid_string(channel_listen_port)):
LOGGER.error(
'mchain bad format, p2p_listen_port is %s, '
'jsonrpc_port is %s, channel_port is %s', p2p_listen_port,
jsonrpc_listen_port, channel_listen_port)
raise MCError('mchain bad format, p2p_listen_port is %s, '
'jsonrpc_port is %s, channel_port is %s' %
(p2p_listen_port, jsonrpc_listen_port,
channel_listen_port))
MchainConf.p2p_ip.append(p2p_ip)
MchainConf.rpc_ip.append(rpc_ip)
MchainConf.p2p_listen_port.append(p2p_listen_port)
MchainConf.jsonrpc_listen_port.append(jsonrpc_listen_port)
MchainConf.channel_listen_port.append(channel_listen_port)
else:
LOGGER.warning(' node%s not existed, break!', idx)
break
# if config_parser.has_section('peers'):
# for peer in config_parser.items('peers'):
# MchainConf.peers.append(peer[1])
# else:
# LOGGER.warning(' section peers not existed!')
LOGGER.info('group_id is %s', MchainConf.group_id)
LOGGER.info('p2p_ip is %s', MchainConf.p2p_ip)
LOGGER.info('rpc_ip is %s', MchainConf.rpc_ip)
LOGGER.info('p2p_listen_port is %s', MchainConf.p2p_listen_port)
LOGGER.info('jsonrpc_listen_port is %s', MchainConf.jsonrpc_listen_port)
LOGGER.info('channel_listen_port is %s', MchainConf.channel_listen_port)
LOGGER.info('peers is %s', MchainConf.peers)
LOGGER.info('node_installation.ini end, result is %s', MchainConf())
def build_package_only(_data_dir):
"""[-- build create config_ini]
Keyword Arguments:
_meta_dir {[PATH]} -- [input dir] (default: {meta})
_data_dir {[PATH]} -- [output dir] (default: {data})
Raises:
MCError -- [description]
MCError -- [description]
MCError -- [description]
MCError -- [description]
"""
LOGGER.info("build_package_only start ")
p2p_listen_port = mconf.MchainConf.p2p_listen_port
jsonrpc_listen_port = mconf.MchainConf.jsonrpc_listen_port
channel_listen_port = mconf.MchainConf.channel_listen_port
p2p_ip = mconf.MchainConf.p2p_ip
rpc_ip = mconf.MchainConf.rpc_ip
channel_ip = mconf.MchainConf.channel_ip
peers = mconf.MchainConf.peers
meta_dir = '{}/meta'.format(path.get_path())
conf_dir = meta_dir
package_dir = _data_dir
gm_opr = utils.Status.gm_option
if os.path.exists(package_dir):
LOGGER.error(' %s existed, maybe u had created it!', package_dir)
raise MCError(' %s existed, maybe u had created it!' % package_dir)
os.mkdir(package_dir)
if gm_opr:
shutil.copy('{}/tpl/config.ini.gm'.format(path.get_path()),
'{}/.config.ini'.format(conf_dir))
else:
shutil.copy('{}/tpl/config.ini'.format(path.get_path()),
'{}/.config.ini'.format(conf_dir))
fin_p2p_ip = []
if not peers:
LOGGER.warning('section peers not existed!')
CONSOLER.warn('section peers not existed!')
else:
for _, peer in enumerate(peers):
fin_p2p_ip.append(peer)
# init config.ini & node package
for my_node_index, node_ip in enumerate(p2p_ip):
LOGGER.info("p2p_ip -> %s", node_ip)
CONSOLER.info(' Generate %s/node_%s_%s ',
package_dir, node_ip, p2p_listen_port[my_node_index])
node_dir = '{}/node_{}_{}'.format(package_dir,
node_ip, p2p_listen_port[my_node_index])
os.mkdir(node_dir)
os.mkdir('{}/scripts'.format(node_dir))
shutil.copy('{}/tpl/start.sh'.format(path.get_path()),
'{}/start.sh'.format(node_dir))
shutil.copy('{}/tpl/stop.sh'.format(path.get_path()),
'{}/stop.sh'.format(node_dir))
shutil.copy('{}/tpl/load_new_groups.sh'.format(path.get_path()),
'{}/scripts/load_new_groups.sh'.format(node_dir))
shutil.copy('{}/tpl/reload_whitelist.sh'.format(path.get_path()),
'{}/scripts/reload_whitelist.sh'.format(node_dir))
shutil.copy('{}/fisco-bcos'.format(meta_dir),
'{}/fisco-bcos'.format(node_dir))
os.mkdir('{}/conf'.format(node_dir))
try:
# cp config.ini
shutil.copy('{}/.config.ini'.format(conf_dir),
'{}/config.ini'.format(node_dir))
except Exception as build_exp:
LOGGER.error(' exception is %s', build_exp)
utils.delete_data(package_dir)
raise MCError(' exception is %s' % build_exp)
node_cfg = configparser.ConfigParser(allow_no_value=True)
try:
with codecs.open('{}/config.ini'.format(node_dir),
'r', encoding='utf-8') as config_file:
node_cfg.readfp(config_file)
except Exception as build_exp:
LOGGER.error(
' open config.ini file failed, exception is %s', build_exp)
utils.delete_data(package_dir)
raise MCError(
' open config.ini file failed, exception is %s' % build_exp)
if len(rpc_ip) > my_node_index:
node_cfg.set("rpc", "jsonrpc_listen_ip", rpc_ip[my_node_index])
else:
node_cfg.set("rpc", "jsonrpc_listen_ip", "127.0.0.1")
if len(channel_ip) > my_node_index:
node_cfg.set("rpc", "channel_listen_ip", channel_ip[my_node_index])
else:
node_cfg.set("rpc", "channel_listen_ip", "0.0.0.0")
node_cfg.set("rpc", "channel_listen_port",
channel_listen_port[my_node_index])
node_cfg.set("rpc", "jsonrpc_listen_port",
jsonrpc_listen_port[my_node_index])
node_cfg.set("p2p", "listen_port", p2p_listen_port[my_node_index])
with open('{}/config.ini'.format(node_dir), 'w') as config_file:
node_cfg.write(config_file)
config_file.close()
# set p2p ip in config.ini
for my_node_index, ip_item in enumerate(p2p_ip):
node_cfg = configparser.ConfigParser(allow_no_value=True)
if not utils.valid_ip(ip_item):
LOGGER.error(
' init config.ini file failed, found ip => %s', ip_item)
utils.delete_data(package_dir)
raise MCError(
' init config.ini file failed, found ip => %s' % ip_item)
node_dir = '{}/node_{}_{}'.format(package_dir,
ip_item, p2p_listen_port[my_node_index])
try:
with codecs.open('{}/config.ini'.format(node_dir),
'r', encoding='utf-8') as config_file:
node_cfg.readfp(config_file)
except Exception as build_exp:
LOGGER.error(
' open config.ini file failed, exception is %s', build_exp)
utils.delete_data(package_dir)
raise MCError(
' open config.ini file failed, exception is %s' % build_exp)
# write p2pip:port into config.ini
for ip_idx, set_item in enumerate(p2p_ip):
fin_p2p_ip.append("{}:{}".format(
set_item, p2p_listen_port[ip_idx]))
fin_p2p_ip = list(set(fin_p2p_ip))
for index, p2p_section in enumerate(fin_p2p_ip):
node_cfg.set("p2p", "node.{}".format(index),
'{}'.format(p2p_section))
node_cfg.set('certificate_whitelist',
'; cal.0 should be nodeid, nodeid\'s length is 128')
node_cfg.set('certificate_whitelist', ';cal.0=')
node_cfg.set('certificate_blacklist',
'; crl.0 should be nodeid, nodeid\'s length is 128')
node_cfg.set('certificate_blacklist', ';crl.0=')
with open('{}/config.ini'.format(node_dir), 'w') as config_file:
node_cfg.write(config_file)
os.mkdir(package_dir + '/scripts/')
shutil.copy('{}/scripts/install.sh'.format(path.get_path()),
package_dir + '/scripts/')
shutil.copy('{}/scripts/pack.sh'.format(path.get_path()),
package_dir + '/scripts/')
shutil.copy('{}/tpl/start_all.sh'.format(path.get_path()), package_dir)
shutil.copy('{}/tpl/stop_all.sh'.format(path.get_path()), package_dir)
shutil.copytree('{}/scripts/monitor'.format((path.get_path())),
'{}/monitor'.format(package_dir))
LOGGER.info("build_package_only end!")
