def test_save_and_restore_user_configure(self):
# GIVEN
conf.DISABLE_V1_API = False
conf.CHANNEL_OPTION = {
conf.LOOPCHAIN_DEFAULT_CHANNEL: {
"load_cert":
False,
"consensus_cert_use":
False,
"tx_cert_use":
False,
"key_load_type":
conf.KeyLoadType.FILE_LOAD,
"public_path":
os.path.join(conf.LOOPCHAIN_ROOT_PATH,
'resources/default_pki/public.der'),
"private_path":
os.path.join(conf.LOOPCHAIN_ROOT_PATH,
'resources/default_pki/private.der'),
"private_password":
b'test'
},
conf.LOOPCHAIN_TEST_CHANNEL: {
"load_cert":
False,
"consensus_cert_use":
False,
"tx_cert_use":
False,
"key_load_type":
conf.KeyLoadType.FILE_LOAD,
"public_path":
os.path.join(conf.LOOPCHAIN_ROOT_PATH,
'resources/default_pki/public.der'),
"private_path":
os.path.join(conf.LOOPCHAIN_ROOT_PATH,
'resources/default_pki/private.der'),
"private_password":
b'test'
}
}
# WHEN
conf.Configure().save_user_configure_with_current_set()
# THEN
self.assertEqual(conf.DISABLE_V1_API, False)
# WHEN
conf.Configure().cleanup_configuration_setting_to_default()
# THEN
self.assertNotEqual(conf.DISABLE_V1_API, False)
def test_load_configure_json(self):
# GIVEN
ip_local_before_load_json = conf.IP_LOCAL
token_type_token_before_load_json = conf_default.TOKEN_TYPE_TOKEN
logging.debug(
f"before json file load, conf.IP_LOCAL({ip_local_before_load_json})"
f", conf.TOKEN_TYPE_TOKEN({token_type_token_before_load_json})")
test_configure_json_path = "configure_json_for_test.json"
configure_json_file = Path(test_configure_json_path)
if not configure_json_file.is_file():
test_configure_json_path = "testcase/unittest/configure_json_for_test.json"
# WHEN
conf.Configure().load_configure_json(test_configure_json_path)
logging.debug(f"after json file load, conf.IP_LOCAL({conf.IP_LOCAL})"
f", conf.TOKEN_TYPE_TOKEN({conf.TOKEN_TYPE_TOKEN})")
# THEN
self.assertNotEqual(ip_local_before_load_json, conf.IP_LOCAL)
self.assertNotEqual(token_type_token_before_load_json,
conf.TOKEN_TYPE_TOKEN)
# BACK
conf.IP_LOCAL = ip_local_before_load_json
conf.TOKEN_TYPE_TOKEN = token_type_token_before_load_json
def main(argv):
parser = argparse.ArgumentParser()
for cmd_arg_type in command_arguments.Type:
cmd_arg_attr = command_arguments.attributes[cmd_arg_type]
parser.add_argument(*cmd_arg_attr.names, **cmd_arg_attr.kwargs)
args, unknowns = parse_args_include_unknowns(parser, argv)
quick_command = get_quick_command(unknowns)
if args.version:
print(json.dumps(conf.ICON_VERSIONS, indent=2))
parser.exit()
command_arguments.set_raw_commands(args)
if args.radio_station_target == 'testnet':
args.radio_station_target = conf.URL_CITIZEN_TESTNET
args.configure_file_path = conf.CONF_PATH_LOOPCHAIN_TESTNET
elif args.radio_station_target == 'mainnet':
args.radio_station_target = conf.URL_CITIZEN_MAINNET
args.configure_file_path = conf.CONF_PATH_LOOPCHAIN_MAINNET
if args.configure_file_path:
conf.Configure().load_configure_json(args.configure_file_path)
if args.key_convert:
key_convert()
parser.exit()
if args.develop:
loggers.set_preset_type(loggers.PresetType.develop)
else:
loggers.set_preset_type(loggers.PresetType.production)
logger_preset = loggers.get_preset()
logger_preset.service_type = args.service_type
loggers.update_preset(False)
loggers.update_other_loggers()
grpc_patcher.monkey_patch()
async_.thread_monkey_patch()
async_.concurrent_future_monkey_patch()
if args.service_type in ("peer", "citizen"):
start_as_peer(args)
elif args.service_type == "rest":
start_as_rest_server(args)
elif args.service_type == "score":
start_as_score(args)
elif args.service_type == "channel":
start_as_channel(args)
elif args.service_type == "tool":
start_as_tool(args, quick_command)
elif args.service_type == "admin":
start_as_admin(args, quick_command)
else:
print(
f"not supported service type {args.service_type}\ncheck loopchain help.\n"
)
parser.print_help()
def main(argv):
parser = argparse.ArgumentParser()
for cmd_arg_type in command_arguments.Type:
cmd_arg_attr = command_arguments.attributes[cmd_arg_type]
parser.add_argument(*cmd_arg_attr.names, **cmd_arg_attr.kwargs)
args = parser.parse_args(argv)
command_arguments.set_raw_commands(args)
if args.radio_station_target == 'testnet':
args.radio_station_target = conf.URL_CITIZEN_TESTNET
args.configure_file_path = conf.CONF_PATH_LOOPCHAIN_TESTNET
elif args.radio_station_target == 'mainnet':
args.radio_station_target = conf.URL_CITIZEN_MAINNET
args.configure_file_path = conf.CONF_PATH_LOOPCHAIN_MAINNET
if args.configure_file_path:
conf.Configure().load_configure_json(args.configure_file_path)
if args.develop:
loggers.set_preset_type(loggers.PresetType.develop)
else:
loggers.set_preset_type(loggers.PresetType.production)
logger_preset = loggers.get_preset()
logger_preset.service_type = args.service_type
loggers.update_preset(False)
loggers.update_other_loggers()
grpc_patcher.monkey_patch()
async .thread_monkey_patch()
async .concurrent_future_monkey_patch()
if args.service_type == "peer":
start_as_peer(args, conf.NodeType.CommunityNode)
elif args.service_type == "citizen":
start_as_peer(args, conf.NodeType.CitizenNode)
elif args.service_type == "rs" or args.service_type == "radiostation":
start_as_rs(args)
elif args.service_type == "rest":
start_as_rest_server(args)
elif args.service_type == "rest-rs":
start_as_rest_server_rs(args)
elif args.service_type == "score":
start_as_score(args)
elif args.service_type == "channel":
start_as_channel(args)
elif args.service_type == "tool":
start_as_tool(args)
elif args.service_type == "admin":
start_as_admin(args)
else:
print(
f"not supported service type {args.service_type}\ncheck loopchain help.\n"
)
os.system("python3 ./loopchain.py -h")
def main(argv):
logging.info("RadioStation main got argv(list): " + str(argv))
try:
opts, args = getopt.getopt(
argv, "dhp:o:s:",
["help", "port=", "cert=", "configure_file_path=", "seed="])
except getopt.GetoptError as e:
logging.error(e)
usage()
sys.exit(1)
# apply json configure values
for opt, arg in opts:
if (opt == "-o") or (opt == "--configure_file_path"):
conf.Configure().load_configure_json(arg)
# apply default configure values
port = conf.PORT_RADIOSTATION
cert = None
pw = None
seed = None
# apply option values
for opt, arg in opts:
if opt == "-d":
util.set_log_level_debug()
elif (opt == "-p") or (opt == "--port"):
port = arg
elif opt == "--cert":
cert = arg
elif (opt == "-s") or (opt == "--seed"):
try:
seed = int(arg)
except ValueError as e:
util.exit_and_msg(f"seed or s opt must be int \n"
f"intput value : {arg}")
elif (opt == "-h") or (opt == "--help"):
usage()
return
# Check Port is Using
if util.check_port_using(conf.IP_RADIOSTATION, int(port)):
logging.error('RadioStation Service Port is Using ' + str(port))
return
RadioStationService(conf.IP_RADIOSTATION, cert, pw, seed).serve(port)
def test_load_configure_json(self):
# GIVEN
ip_local_before_load_json = conf.IP_LOCAL
logging.debug(
f"before json file load, conf.IP_LOCAL({ip_local_before_load_json})"
)
test_configure_json_path = "configure_json_for_test.json"
configure_json_file = Path(test_configure_json_path)
if not configure_json_file.is_file():
test_configure_json_path = "tests/unit/configure_json_for_test.json"
# WHEN
conf.Configure().load_configure_json(test_configure_json_path)
logging.debug(f"after json file load, conf.IP_LOCAL({conf.IP_LOCAL})")
# THEN
self.assertNotEqual(ip_local_before_load_json, conf.IP_LOCAL)
# BACK
conf.IP_LOCAL = ip_local_before_load_json
def setUp(self):
conf.Configure().init_configure()
test_util.print_testname(self._testMethodName)
self.peer_auth = Signer.from_prikey(os.urandom(32))
set_mock(self)
def main(argv):
# logging.debug("Peer main got argv(list): " + str(argv))
try:
opts, args = getopt.getopt(argv, "dhr:p:c:o:a:", [
"help", "radio_station_target=", "port=", "score=", "public=",
"private=", "password="******"configure_file_path="
])
except getopt.GetoptError as e:
logging.error(e)
usage()
sys.exit(1)
# apply json configure values
for opt, arg in opts:
if (opt == "-o") or (opt == "--configure_file_path"):
conf.Configure().load_configure_json(arg)
# apply default configure values
port = conf.PORT_PEER
radio_station_ip = conf.IP_RADIOSTATION
radio_station_port = conf.PORT_RADIOSTATION
radio_station_ip_sub = conf.IP_RADIOSTATION
radio_station_port_sub = conf.PORT_RADIOSTATION
score = conf.DEFAULT_SCORE_PACKAGE
public = conf.PUBLIC_PATH
private = conf.PRIVATE_PATH
pw = conf.DEFAULT_PW
# Parse command line arguments.
for opt, arg in opts:
if (opt == "-r") or (opt == "--radio_station_target"):
try:
if ':' in arg:
target_list = util.parse_target_list(arg)
if len(target_list) == 2:
radio_station_ip, radio_station_port = target_list[0]
radio_station_ip_sub, radio_station_port_sub = target_list[
1]
else:
radio_station_ip, radio_station_port = target_list[0]
# util.logger.spam(f"peer "
# f"radio_station_ip({radio_station_ip}) "
# f"radio_station_port({radio_station_port}) "
# f"radio_station_ip_sub({radio_station_ip_sub}) "
# f"radio_station_port_sub({radio_station_port_sub})")
elif len(arg.split('.')) == 4:
radio_station_ip = arg
else:
raise Exception("Invalid IP format")
except Exception as e:
util.exit_and_msg(
f"'-r' or '--radio_station_target' option requires "
f"[IP Address of Radio Station]:[PORT number of Radio Station], "
f"or just [IP Address of Radio Station] format. error({e})"
)
elif (opt == "-p") or (opt == "--port"):
port = arg
elif (opt == "-c") or (opt == "--score"):
score = arg
elif (opt == "-a") or (opt == "--password"):
pw = arg
elif opt == "--public":
public = arg
elif opt == "--private":
private = arg
elif opt == "-d":
util.set_log_level_debug()
elif (opt == "-h") or (opt == "--help"):
usage()
return
# run peer service with parameters
logging.info(f"loopchain peer run with: port({port}) "
f"radio station({radio_station_ip}:{radio_station_port}) "
f"score({score})")
# check Port Using
if util.check_port_using(conf.IP_PEER, int(port)):
util.exit_and_msg('Peer Service Port is Using ' + str(port))
# str password to bytes
if isinstance(pw, str):
pw = pw.encode()
ObjectManager().peer_service = PeerService(
radio_station_ip=radio_station_ip,
radio_station_port=radio_station_port,
public_path=public,
private_path=private,
cert_pass=pw)
# logging.debug("loopchain peer_service is: " + str(ObjectManager().peer_service))
ObjectManager().peer_service.serve(port, score)
def setUp(self):
conf.ENABLE_USER_CONFIG = False
conf.Configure().init_configure()
test_util.print_testname(self._testMethodName)
self.peer_auth = test_util.create_default_peer_auth()
set_mock(self)
