def version():
"""load release_node.txt, print version number.
"""
with open('{}/release_note.txt'.format(path.get_path()),
'r') as file_releas:
CONSOLER.info(file_releas.read())
def get_console_file(_file):
"""[get console file]
Arguments:
_file {[type]} -- [description]
"""
data = _file
utils.file_must_exists(data)
p2p_ip = mconf.MchainConf.p2p_ip
channel_listen_port = mconf.MchainConf.channel_listen_port
channel_addr = []
group_id = mconf.MchainConf.group_id
utils.replace(data, '"group1', '"group{}'.format(group_id))
utils.replace(data, 'name="groupId" value="1"',
'name="groupId" value="{}"'.format(group_id))
for ip_idx, p2p_get in enumerate(p2p_ip):
channel_addr.append('{}:{}'.format(p2p_get,
channel_listen_port[ip_idx]))
cmd = "cat {} | grep -n connectionsStr | awk '{{print $1}}'".format(data)
(status, result) = utils.getstatusoutput(cmd)
result = result.strip('\n').strip(':')
if bool(status):
LOGGER.error(' append console channel_addr failed, result is %s.',
result)
raise MCError(' append console channel_addr failed, result is %s.' %
result)
line_num = int(result) + 1
for channel in channel_addr:
(status, result) \
= utils.getstatusoutput('sed -i "{} a'
'<value>{}</value>" {}'
.format(line_num, channel, data))
line_num = line_num + 1
CONSOLER.info('get console file end')
def build_console(_console_dir):
"""[download console]
Arguments:
_console_dir {[type]} -- [description]
"""
data = _console_dir
utils.download_console(data)
CONSOLER.info(
"download console success, obtain the sdk certificates now...")
if utils.Status.gm_ssl:
opr_cert.get_console_cert_gmssl('{}/console/conf'.format(data))
else:
opr_cert.get_console_cert('{}/console/conf'.format(data))
CONSOLER.info(
"obtain the sdk certificates success, configure the console now")
if utils.console_use_xml_configuration():
CONSOLER.info("configure applicationContext.xml")
shutil.copyfile(
'{}/tpl/applicationContext.xml'.format(path.get_path()),
'{}/console/conf/applicationContext.xml'.format(data))
config.get_console_file(
'{}/console/conf/applicationContext.xml'.format(data))
else:
CONSOLER.info("configure config-example.toml")
# copy the config-example.toml to config.toml
shutil.copyfile('{}/console/conf/config-example.toml'.format(data),
'{}/console/conf/config.toml'.format(data))
# update the connections
config.config_console_toml_file(
'{}/console/conf/config.toml'.format(data))
CONSOLER.info("configure the console success")
def generate_root_ca(_dir):
"""[generate root cert]
Arguments:
dir {[path]} -- [root cert path]
"""
try:
ca_dir = os.path.abspath(_dir)
if utils.Status.gm_option:
os.chdir('{}/scripts/gm/'.format(path.get_path()))
(status, result) = utils.getstatusoutput('./cts.sh gen_chain_cert {}'
.format(ca_dir))
os.chdir('{}'.format(path.get_path()))
else:
os.chdir('{}/scripts'.format(path.get_path()))
(status, result) = utils.getstatusoutput('./cts.sh gen_chain_cert {}'
.format(ca_dir))
os.chdir('{}'.format(path.get_path()))
if bool(status):
LOGGER.error(
' cts.sh failed! status is %d, output is %s, dir is %s.', status, result, ca_dir)
raise MCError('cts.sh failed! status is %d, output is %s, dir is %s.' % (
status, result, ca_dir))
LOGGER.info(
' cts.sh success! status is %d, output is %s, dir is %s.', status, result, ca_dir)
LOGGER.info(' Generate root cert success, dir is %s', ca_dir)
CONSOLER.info(' Generate root cert success, dir is %s', ca_dir)
except MCError as cert_exp:
console_error(' %s ' % cert_exp)
except Exception as gen_cert_exp:
console_error(
' Generate root cert failed! excepion is %s.' % gen_cert_exp)
LOGGER.error(' Generate root cert failed! Result is %s', result)
raise MCError(
'Generate root agency failed! Result is %s' % gen_cert_exp)
def set_download_console_version(version):
"""
set download_console_version
"""
Status.download_console_version = version
Status.download_console_version_specified = True
CONSOLER.debug("expect to download console %s",
Status.download_console_version)
def download_console(_dir):
"""[summary]
Arguments:
_dir {[type]} -- [description]
Raises:
MCError -- [description]
MCError -- [description]
"""
dir_must_exists(_dir)
bin_path = _dir
meta = '{}/meta'.format(path.get_path())
file_must_exists('{}/ca.crt'.format(meta))
file_must_exists('{}/agency.crt'.format(meta))
file_must_exists('{}/agency.key'.format(meta))
package_name = "console.tar.gz"
dir_must_not_exists('{}/console'.format(bin_path))
(status, version) = getstatusoutput(
'curl -s https://api.github.com/repos/FISCO-BCOS/'
'console/releases | grep "tag_name" '
'| sort -u | tail -n 1 | cut -d \\" -f 4 | sed "s/^[vV]//"')
if bool(status):
LOGGER.error(' get fisco-bcos verion failed, result is %s.', version)
raise MCError(' get fisco-bcos verion failed, result is %s.' % version)
download_link = 'https://github.com/FISCO-BCOS/console/releases/download/v{}/{}'.format(
version.strip('\n'), package_name.strip('\n'))
cnd_link = 'https://www.fisco.com.cn/cdn/console/releases/download/v{}/{}'.format(
version.strip('\n'), package_name.strip('\n'))
if valid_url(cnd_link):
LOGGER.info("Downloading console binary from %s", cnd_link)
CONSOLER.info("Downloading console binary from %s", cnd_link)
download_bin(cnd_link, package_name)
elif valid_url(download_link):
LOGGER.info("Downloading console binary from %s", download_link)
CONSOLER.info("Downloading console binary from %s", download_link)
download_bin(download_link, package_name)
else:
LOGGER.error(' Download console failed, Please check your network!')
raise MCError(' Download console failed, Please check your network!')
(status, result)\
= getstatusoutput('tar -zxf {} -C {} && '
'rm {}'.format(package_name,
bin_path,
package_name))
if bool(status):
LOGGER.error(' Decompress console failed, result is %s.', result)
raise MCError(' Decompress console failed, result is %s.' % result)
(status, result) = getstatusoutput(
'chmod a+x {}/console/start.sh'.format(bin_path))
if bool(status):
LOGGER.error('chmod console failed! status is %d,'
' output is %s.', status, result)
raise MCError('chmod console failed!'
' status is %d, output is %s.' % (status, result))
def download_fisco(_dir):
"""[download fisco-bcos]
Arguments:
_dir {[type]} -- [description]
"""
bin_path = _dir
# bcos_bin_name = 'fisco-bcos'
if Status.gm_option:
package_name = "fisco-bcos-gm.tar.gz"
else:
package_name = "fisco-bcos.tar.gz"
(status, version)\
= getstatusoutput('curl -s https://raw.githubusercontent.com/'
'FISCO-BCOS/FISCO-BCOS/master/release_note.txt | sed "s/^[vV]//"')
if bool(status):
LOGGER.error(
' get fisco-bcos verion failed, result is %s.', version)
raise MCError(' get fisco-bcos verion failed, result is %s.' % version)
download_link = 'https://github.com/FISCO-BCOS/FISCO-BCOS/releases/download/v{}/{}'.format(
version.strip('\n'), package_name.strip('\n'))
# filename = package_name
LOGGER.info("Downloading fisco-bcos binary from %s", download_link)
CONSOLER.info("Downloading fisco-bcos binary from %s", download_link)
# (status, result) = getstatusoutput('curl -LO {}'.format(download_link))
# subprocess.call('curl -LO {}'.format(download_link), shell=True)
download_bin(download_link, package_name)
# if bool(status):
# LOGGER.error(
# ' download fisco-bcos failed, result is %s.', result)
# raise MCError(
# ' download fisco-bcos failed, result is %s.' % result)
(status, result)\
= getstatusoutput('tar -zxf {} && mv fisco-bcos {} && rm {}'.format(package_name,
bin_path,
package_name))
if bool(status):
LOGGER.error(
' Decompress fisco-bcos failed, result is %s.', result)
raise MCError(
' Decompress fisco-bcos failed, result is %s.' % result)
(status, result) = getstatusoutput('chmod a+x {}'.format(bin_path))
if bool(status):
LOGGER.error(
' exec fisco-bcos failed, result is %s.', result)
raise MCError(
' exec fisco-bcos failed, result is %s.' % result)
LOGGER.info("Downloading fisco-bcos successful, fisco-bcos at %s", bin_path)
CONSOLER.info(
"Downloading fisco-bcos successful, fisco-bcos at %s", bin_path)
def get_console_cert(_dir):
"""get console certs
Arguments:
_dir {[type]} -- [description]
"""
LOGGER.info("get console in %s!", _dir)
CONSOLER.info("get console in %s!", _dir)
meta = '{}/meta'.format(path.get_path())
data = _dir
get_sdk_cert()
utils.dir_must_exists(data)
shutil.copyfile('{}/ca.crt'.format(meta), '{}/ca.crt'.format(data))
shutil.copyfile('{}/sdk/node.key'.format(meta), '{}/node.key'.format(data))
shutil.copyfile('{}/sdk/node.crt'.format(meta), '{}/node.crt'.format(data))
def download_console(_dir):
"""[summary]
Arguments:
_dir {[type]} -- [description]
Raises:
MCError -- [description]
MCError -- [description]
"""
dir_must_exists(_dir)
bin_path = _dir
meta = '{}/meta'.format(path.get_path())
# file_must_exists('{}/ca.crt'.format(meta))
# file_must_exists('{}/agency.crt'.format(meta))
# file_must_exists('{}/agency.key'.format(meta))
download_console_command = "bash {}/tpl/{}".format(
path.get_path(), Status.download_console_shell_script)
cdn_option = ""
if Status.use_cdn:
CONSOLER.info("download_console: use cdn")
cdn_option = "-n"
download_console_command = "{} {}".format(download_console_command,
cdn_option)
if (Status.download_console_version_specified is True):
download_console_command = "{} -c {}".format(
download_console_command, Status.download_console_version)
if (Status.solidity_version_specified is True):
download_console_command = "{} -v {}".format(download_console_command,
Status.solidity_version)
CONSOLER.info("The download_console_command is %s",
download_console_command)
# execute the download_console_command
(status, result) = getstatusoutput(download_console_command)
if bool(status):
LOGGER.error(' download console failed, result is %s.', result)
raise MCError(' download console failed, result is %s.' % result)
chmod_command = 'chmod a+x console/start.sh'
if bin_path != "." and bin_path != "./":
chmod_command = "{} && mv console {}".format(chmod_command, bin_path)
(status, result) = getstatusoutput(chmod_command)
if bool(status):
LOGGER.error('chmod console failed! status is %d,'
' output is %s.', status, result)
raise MCError('chmod console failed!'
' status is %d, output is %s.' % (status, result))
def check_fisco(_file):
"""checkfisco
"""
bin_fisco = _file
CONSOLER.info(" Checking fisco-bcos binary...")
LOGGER.info(" Checking fisco-bcos binary...")
(status, bin_version)\
= getstatusoutput('{} -v'.format(bin_fisco))
if bool(status):
LOGGER.error(
'Checking fisco-bcos failed! status is %d,'
' output is %s, dir is %s.', status, bin_version, bin_fisco)
raise MCError('Checking fisco-bcos failed!'
' status is %d, output is %s, dir is %s.' %
(status, bin_version, bin_fisco))
if not 'FISCO-BCOS' in bin_version:
LOGGER.error("%s is wrong. Please correct it and try again.",
bin_fisco)
raise Exception("%s is wrong. Please correct it and try again." %
bin_fisco)
if Status.gm_option:
if not 'gm' in bin_version:
LOGGER.error(
'Checking fisco-bcos failed! %s isn\'t '
'gm version. Please correct it and try again.', bin_fisco)
raise MCError('Checking fisco-bcos failed! %s isn\'t '
'gm version. Please correct it and try again' %
bin_version)
else:
if 'gm' in bin_version:
LOGGER.error(
'Checking fisco-bcos failed! %s isn\'t '
'standard version. Please correct it and try again.',
bin_fisco)
raise MCError(
'Checking fisco-bcos failed! %s isn\'t '
'standard version. Please correct it and try again.' %
bin_version)
CONSOLER.info(' Binary check passed.')
LOGGER.info(' Binary check passed.')
def download_console(_dir):
"""[summary]
Arguments:
_dir {[type]} -- [description]
Raises:
MCError -- [description]
MCError -- [description]
"""
bin_path = _dir
package_name = "console.tar.gz"
dir_must_not_exists('{}/console'.format(bin_path))
(status, version) = getstatusoutput('curl -s https://raw.githubusercontent.com/'
'FISCO-BCOS/console/master/release_note.txt'
' | sed "s/^[vV]//"')
if bool(status):
LOGGER.error(
' get fisco-bcos verion failed, result is %s.', version)
raise MCError(' get fisco-bcos verion failed, result is %s.' % version)
download_link = 'https://github.com/FISCO-BCOS/console/releases/download/v{}/{}'.format(
version.strip('\n'), package_name.strip('\n'))
LOGGER.info("Downloading console binary %s", download_link)
CONSOLER.info("Downloading console binary %s", download_link)
download_bin(download_link, package_name)
# subprocess.call('curl -LO {}'.format(download_link), shell=True)
(status, result)\
= getstatusoutput('tar -zxf {} -C {} && '
'rm {}'.format(package_name,
bin_path,
package_name))
if bool(status):
LOGGER.error(
' Decompress console failed, result is %s.', result)
raise MCError(
' Decompress console failed, result is %s.' % result)
(status, result) = getstatusoutput(
'chmod a+x {}/console/start.sh'.format(bin_path))
def config_console_toml_file(_file):
"""
config config.toml of the console
"""
utils.file_must_exists(_file)
# Note: the default ip the console connects to is 127.0.0.1
rpc_ip = mconf.MchainConf.rpc_ip
channel_listen_port = mconf.MchainConf.channel_listen_port
with open(_file, mode='rb') as fp:
content = fp.read()
if content.startswith(b'\xef\xbb\xbf'):
content = content[3:]
config = toml.loads(content.decode('utf8'))
for ip_idx, rpc_get in enumerate(rpc_ip):
config["network"]["peers"][ip_idx] = "{}:{}".format(
rpc_get, channel_listen_port[ip_idx])
CONSOLER.info("configure the channel connections to %s",
config["network"]["peers"])
with open(_file, 'w') as fd:
toml.dump(config, fd)
CONSOLER.info("config_console_toml_file success")
def download_fisco(_dir):
"""[download fisco-bcos]
Arguments:
_dir {[type]} -- [description]
"""
dir_must_exists(_dir)
bin_path = _dir
# bcos_bin_name = 'fisco-bcos'
if Status.gm_option:
package_name = "fisco-bcos-gm.tar.gz"
else:
package_name = "fisco-bcos.tar.gz"
(status, version)\
= getstatusoutput(r'curl -s https://api.github.com/repos/FISCO-BCOS/FISCO-BCOS/releases '
r'| grep "tag_name" | grep "\"v2\.[0-9]\.[0-9]\""'
r' | sort -u | tail -n 1 | cut -d \" -f 4 | sed "s/^[vV]//"')
if bool(status):
LOGGER.error(' get fisco-bcos verion failed, result is %s.', version)
raise MCError(' get fisco-bcos verion failed, result is %s.' % version)
download_link = 'https://github.com/FISCO-BCOS/FISCO-BCOS/releases/download/v{}/{}'.format(
version.strip('\n'), package_name.strip('\n'))
cnd_link = 'https://www.fisco.com.cn/cdn/fisco-bcos/releases/download/v{}/{}'.format(
version.strip('\n'), package_name.strip('\n'))
if valid_url(cnd_link):
LOGGER.info("Downloading fisco-bcos binary from %s", cnd_link)
CONSOLER.info("Downloading fisco-bcos binary from %s", cnd_link)
download_bin(cnd_link, package_name)
elif valid_url(download_link):
LOGGER.info("Downloading fisco-bcos binary from %s", download_link)
CONSOLER.info("Downloading fisco-bcos binary from %s", download_link)
download_bin(download_link, package_name)
else:
LOGGER.error(' Download fisco-bcos failed, Please check your network!')
raise MCError(
' Download fisco-bcos failed, Please check your network!')
(status, result)\
= getstatusoutput('tar -zxf {} -C {} && rm {}'.format(package_name,
bin_path,
package_name))
if bool(status):
LOGGER.error(' Decompress fisco-bcos failed, result is %s.', result)
raise MCError(' Decompress fisco-bcos failed, result is %s.' % result)
(status, result) = getstatusoutput('chmod a+x {}'.format(bin_path))
if bool(status):
LOGGER.error(' exec fisco-bcos failed, result is %s.', result)
raise MCError(' exec fisco-bcos failed, result is %s.' % result)
LOGGER.info("Downloading fisco-bcos successful, fisco-bcos at %s",
bin_path)
CONSOLER.info("Downloading fisco-bcos successful, fisco-bcos at %s",
bin_path)
def get_sdk_cert():
"""[summary]
Arguments:
_dir {[type]} -- [description]
"""
LOGGER.info("get sdk cert in meta!")
CONSOLER.info("get sdk cert in meta!")
meta = '{}/meta'.format(path.get_path())
utils.file_must_exists('{}/ca.crt'.format(meta))
utils.file_must_exists('{}/agency.crt'.format(meta))
utils.file_must_exists('{}/agency.key'.format(meta))
if os.path.isdir('{}/sdk'.format(meta)):
utils.file_must_exists('{}/sdk/ca.crt'.format(meta))
utils.file_must_exists('{}/sdk/node.crt'.format(meta))
utils.file_must_exists('{}/sdk/node.key'.format(meta))
LOGGER.info("sdk cert existed!")
CONSOLER.info("sdk cert existed!")
else:
LOGGER.info("generate console cert!")
CONSOLER.info("generate console cert!")
ca.generator_node_ca(meta, meta, 'sdk')
def create_group_genesis(data_dir='{}/meta'.format(path.get_path())):
'''
create group in meta
'''
LOGGER.info('create_group_genesis start')
package_dir = data_dir
gm_opr = utils.Status.gm_option
group_id = mgroup.MgroupConf.group_id
p2p_ip = mgroup.MgroupConf.p2p_ip
p2p_listen_port = mgroup.MgroupConf.p2p_listen_port
utils.file_must_not_exists('{}/group.{}.genesis'.format(
data_dir, group_id))
if not os.path.exists(package_dir):
LOGGER.warning(' %s not existed!', package_dir)
os.mkdir(data_dir)
shutil.copy('{}/tpl/group.i.genesis'.format(path.get_path()),
'{}/group.{}.genesis'.format(package_dir, group_id))
shutil.copy('{}/tpl/group.i.ini'.format(path.get_path()),
'{}/group.{}.ini'.format(package_dir, group_id))
# uptes second to ms
(status, time_stamp) = utils.getstatusoutput('echo $(date +%s"000")')
if not bool(status):
CONSOLER.info('generate %s/group.%s.genesis, successful', package_dir,
group_id)
else:
LOGGER.error(
' Generate %s/group.%s.genesis failed! Please check your network.',
package_dir, group_id)
raise MCError(
' Generate %s/group.%s.genesis failed, timestamp is %s! Please check your network.'
% (package_dir, group_id, time_stamp))
# CONSOLER.info('generate %s/group.%s.ini', package_dir, group_id)
group_cfg = configparser.ConfigParser()
with open('{}/group.{}.genesis'.format(package_dir, group_id),
'r') as config_file:
group_cfg.readfp(config_file)
for node_idx, _in in enumerate(p2p_ip):
try:
if gm_opr:
node_id = config.get_nodeid_str(
'{}/meta/gmcert_{}_{}.crt'.format(
path.get_path(), p2p_ip[node_idx],
p2p_listen_port[node_idx]))
node_id.strip('\n').strip(
'WARNING: can\'t open config file: /home/asherli/TASSL/ssl/openssl.cnf'
)
LOGGER.info('resolve %s/meta/gmcert_%s_%s.crt',
path.get_path(), p2p_ip[node_idx],
p2p_listen_port[node_idx])
LOGGER.info("nodeid -> %s", node_id)
group_cfg.set("consensus", "node.{}".format(node_idx), node_id)
else:
node_id = config.get_nodeid_str(
'{}/meta/cert_{}_{}.crt'.format(path.get_path(),
p2p_ip[node_idx],
p2p_listen_port[node_idx]))
LOGGER.info('resolve %s/meta/cert_%s_%s.crt', path.get_path(),
p2p_ip[node_idx], p2p_listen_port[node_idx])
LOGGER.info("nodeid -> %s", node_id)
group_cfg.set("consensus", "node.{}".format(node_idx), node_id)
except Exception as group_exp:
LOGGER.error('create group genesis failed! exception is %s',
group_exp)
raise MCError('create group genesis failed! exception is %s' %
group_exp)
group_cfg.set("group", "id", group_id)
group_cfg.set("group", "timestamp", time_stamp)
with open('{}/group.{}.genesis'.format(package_dir, group_id),
'w') as config_file:
group_cfg.write(config_file)
shutil.copy('{}/group.{}.genesis'.format(package_dir, group_id),
'{}/meta/group.{}.genesis'.format(path.get_path(), group_id))
LOGGER.info('create_group_genesis end')
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 gen_build_cert(_dir):
"""[gen_build_cert]
Arguments:
_dir {[PATH]} -- [cert output]
Raises:
MCError -- [description]
"""
meta_path = '{}/meta'.format(path.get_path())
cert_path = _dir
data_path = meta_path
p2p_listen_port = mconf.MchainConf.p2p_listen_port
p2p_ip = mconf.MchainConf.p2p_ip
utils.file_must_not_exists('{}/peers.txt'.format(cert_path))
if not os.path.exists(cert_path):
os.mkdir(cert_path)
if utils.Status.gm_option:
if not os.path.exists('{}/gmca.crt'.format(meta_path)):
CONSOLER.error(" gmca.crt not existed")
utils.delete_data(cert_path)
raise MCError(' gmca.crt not founded!')
else:
if not os.path.exists('{}/ca.crt'.format(meta_path)):
CONSOLER.error(" ca.crt not existed")
utils.delete_data(cert_path)
raise MCError(' ca.crt not founded!')
if utils.Status.gm_option:
if not (os.path.exists('{}/gmagency.key'.format(meta_path))
and os.path.exists(('{}/gmagency.crt'.format(meta_path)))):
CONSOLER.error(" gmagency.crt or gmagency.key not existed")
utils.delete_data(cert_path)
raise MCError(' gmagency.crt or gmagency.key not found in %s!' %
meta_path)
else:
if not (os.path.exists('{}/agency.key'.format(meta_path))
and os.path.exists(('{}/agency.crt'.format(meta_path)))):
CONSOLER.error(" agency.crt or agency.key not existed")
utils.delete_data(cert_path)
raise MCError(' agency.crt or agency.key not found in %s!' %
meta_path)
for my_node_index, node_ip in enumerate(p2p_ip):
LOGGER.info("p2p_ip -> %s", node_ip)
CONSOLER.info(' Generate %s/node_%s_%s ', data_path, node_ip,
p2p_listen_port[my_node_index])
if utils.Status.gm_option:
utils.file_must_not_exists('{}/gmcert_{}_{}.crt'.format(
meta_path, node_ip, p2p_listen_port[my_node_index]))
else:
utils.file_must_not_exists('{}/cert_{}_{}.crt'.format(
meta_path, node_ip, p2p_listen_port[my_node_index]))
ca.generator_node_ca(
data_path, '{}/'.format(meta_path),
'node_{}_{}'.format(node_ip, p2p_listen_port[my_node_index]))
if utils.Status.gm_option:
utils.off_gm()
if os.path.isdir('./.origin_cert'):
shutil.rmtree('./.origin_cert')
ca.generator_node_ca('./', meta_path, '.origin_cert')
shutil.copytree(
'./.origin_cert', '{}/node_{}_{}/origin_cert'.format(
data_path, node_ip, p2p_listen_port[my_node_index]))
shutil.rmtree('./.origin_cert')
utils.set_gm()
shutil.copyfile(
'{}/node_{}_{}/gmnode.crt'.format(
data_path, node_ip, p2p_listen_port[my_node_index]),
'{}/gmcert_{}_{}.crt'.format(meta_path, node_ip,
p2p_listen_port[my_node_index]))
shutil.copyfile(
'{}/gmcert_{}_{}.crt'.format(meta_path, node_ip,
p2p_listen_port[my_node_index]),
'{}/gmcert_{}_{}.crt'.format(cert_path, node_ip,
p2p_listen_port[my_node_index]))
else:
shutil.copyfile(
'{}/node_{}_{}/node.crt'.format(
data_path, node_ip, p2p_listen_port[my_node_index]),
'{}/cert_{}_{}.crt'.format(meta_path, node_ip,
p2p_listen_port[my_node_index]))
shutil.copyfile(
'{}/cert_{}_{}.crt'.format(meta_path, node_ip,
p2p_listen_port[my_node_index]),
'{}/cert_{}_{}.crt'.format(cert_path, node_ip,
p2p_listen_port[my_node_index]))
(status, result) = \
utils.getstatusoutput('echo {}:{} >> {}/peers.txt'
.format(node_ip,
p2p_listen_port[my_node_index],
cert_path))
LOGGER.info(" status is %s, result is %s", status, result)
CONSOLER.info(" Generate cert by node_installation.ini successful!")
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!")
