def run(ctx: Context, **kwargs: Any) -> None:
# pylint: disable=too-many-locals,too-many-branches,too-many-statements
flamegraph = kwargs.pop("flamegraph", None)
switch_tracing = kwargs.pop("switch_tracing", None)
profiler = None
switch_monitor = None
enable_gevent_monitoring_signal()
if flamegraph:
os.makedirs(flamegraph, exist_ok=True)
now = datetime.datetime.now().isoformat()
address = to_checksum_address(kwargs["address"])
stack_path = os.path.join(flamegraph, f"{address}_{now}_stack.data")
stack_stream = open(stack_path, "w")
flame = FlameGraphCollector(stack_stream)
profiler = TraceSampler(flame)
if switch_tracing is True:
switch_monitor = SwitchMonitoring()
memory_logger = None
log_memory_usage_interval = kwargs.pop("log_memory_usage_interval", 0)
if log_memory_usage_interval > 0:
memory_logger = MemoryLogger(log_memory_usage_interval)
memory_logger.start()
if kwargs.pop("version", False):
click.echo(
click.style("Hint: Use ", fg="green")
+ click.style(f"'{os.path.basename(sys.argv[0])} version'", fg="yellow")
+ click.style(" instead", fg="green")
)
ctx.invoke(version, short=True)
return
if kwargs["config_file"]:
apply_config_file(run, kwargs, ctx)
validate_option_dependencies(run, ctx, kwargs, OPTION_DEPENDENCIES)
if ctx.invoked_subcommand is not None:
# Pass parsed args on to subcommands.
ctx.obj = kwargs
return
if kwargs["transport"] == "matrix":
runner = MatrixRunner(kwargs, ctx)
else:
# Shouldn't happen
raise RuntimeError(f"Invalid transport type '{kwargs['transport']}'")
click.secho(runner.welcome_string, fg="green")
click.secho(
textwrap.dedent(
"""\
----------------------------------------------------------------------
| This is an Alpha version of experimental open source software |
| released as a test version under an MIT license and may contain |
| errors and/or bugs. No guarantee or representations whatsoever is |
| made regarding its suitability (or its use) for any purpose or |
| regarding its compliance with any applicable laws and regulations. |
| Use of the software is at your own risk and discretion and by |
| using the software you acknowledge that you have read this |
| disclaimer, understand its contents, assume all risk related |
| thereto and hereby release, waive, discharge and covenant not to |
| sue Brainbot Labs Establishment or any officers, employees or |
| affiliates from and for any direct or indirect liability resulting |
| from the use of the software as permissible by applicable laws and |
| regulations. |
| |
| Privacy Warning: Please be aware, that by using the Raiden Client, |
| among others, your Ethereum address, channels, channel deposits, |
| settlements and the Ethereum address of your channel counterparty |
| will be stored on the Ethereum chain, i.e. on servers of Ethereum |
| node operators and ergo are to a certain extent publicly available.|
| The same might also be stored on systems of parties running Raiden |
| nodes connected to the same token network. Data present in the |
| Ethereum chain is very unlikely to be able to be changed, removed |
| or deleted from the public arena. |
| |
| Also be aware, that data on individual Raiden token transfers will |
| be made available via the Matrix protocol to the recipient, |
| intermediating nodes of a specific transfer as well as to the |
| Matrix server operators. |
----------------------------------------------------------------------"""
),
fg="yellow",
)
if not kwargs["accept_disclaimer"]:
click.confirm(
"\nHave you read, understood and hereby accept the above "
"disclaimer and privacy warning?",
abort=True,
)
# TODO:
# - Ask for confirmation to quit if there are any locked transfers that did
# not timeout.
try:
runner.run()
except (ReplacementTransactionUnderpriced, EthereumNonceTooLow) as ex:
click.secho(
f"{ex}. Please make sure that this Raiden node is the "
f"only user of the selected account",
fg="red",
)
sys.exit(ReturnCode.ETH_ACCOUNT_ERROR)
except (ConnectionError, ConnectTimeout, RequestsConnectionError, ReadTimeoutError):
print(COMMUNICATION_ERROR.format(kwargs["eth_rpc_endpoint"]))
sys.exit(ReturnCode.GENERIC_COMMUNICATION_ERROR)
except EthNodeInterfaceError as e:
click.secho(str(e), fg="red")
sys.exit(ReturnCode.ETH_INTERFACE_ERROR)
except RaidenUnrecoverableError as ex:
click.secho(f"FATAL: An un-recoverable error happen, Raiden is bailing {ex}", fg="red")
write_stack_trace(ex)
sys.exit(ReturnCode.FATAL)
except APIServerPortInUseError as ex:
click.secho(
f"ERROR: API Address {ex} is in use. Use --api-address <host:port> "
f"to specify a different port.",
fg="red",
)
sys.exit(ReturnCode.PORT_ALREADY_IN_USE)
except (KeystoreAuthenticationError, KeystoreFileNotFound) as e:
click.secho(str(e), fg="red")
sys.exit(ReturnCode.ETH_ACCOUNT_ERROR)
except ConfigurationError as e:
click.secho(str(e), fg="red")
sys.exit(ReturnCode.CONFIGURATION_ERROR)
except filelock.Timeout:
name_or_id = ID_TO_NETWORKNAME.get(kwargs["network_id"], kwargs["network_id"])
click.secho(
f"FATAL: Another Raiden instance already running for account "
f"{to_checksum_address(address)} on network id {name_or_id}",
fg="red",
)
sys.exit(ReturnCode.CONFIGURATION_ERROR)
except Exception as ex:
write_stack_trace(ex)
sys.exit(ReturnCode.FATAL)
finally:
# teardown order is important because of side-effects, both the
# switch_monitor and profiler could use the tracing api, for the
# teardown code to work correctly the teardown has to be done in the
# reverse order of the initialization.
if switch_monitor is not None:
switch_monitor.stop()
if memory_logger is not None:
memory_logger.stop()
if profiler is not None:
profiler.stop()
def auto_enable_gevent_monitoring_signal():
enable_gevent_monitoring_signal()
def smoketest(ctx: Context, debug: bool, eth_client: EthClient,
report_path: Optional[str]) -> None:
""" Test, that the raiden installation is sane. """
from raiden.tests.utils.smoketest import (
setup_raiden,
run_smoketest,
setup_matrix_for_smoketest,
setup_testchain_for_smoketest,
)
from raiden.tests.utils.transport import make_requests_insecure, ParsedURL
from raiden.utils.debugging import enable_gevent_monitoring_signal
step_count = 8
step = 0
stdout = sys.stdout
raiden_stdout = StringIO()
assert ctx.parent, MYPY_ANNOTATION
environment_type = ctx.parent.params["environment_type"]
transport = ctx.parent.params["transport"]
disable_debug_logfile = ctx.parent.params["disable_debug_logfile"]
matrix_server = ctx.parent.params["matrix_server"]
if transport != "matrix":
raise RuntimeError(f"Invalid transport type '{transport}'")
if report_path is None:
report_file = mktemp(suffix=".log")
else:
report_file = report_path
enable_gevent_monitoring_signal()
make_requests_insecure()
urllib3.disable_warnings(InsecureRequestWarning)
click.secho(f"Report file: {report_file}", fg="yellow")
configure_logging(
logger_level_config={"": "DEBUG"},
log_file=report_file,
disable_debug_logfile=disable_debug_logfile,
)
def append_report(subject: str, data: Optional[AnyStr] = None) -> None:
with open(report_file, "a", encoding="UTF-8") as handler:
handler.write(f'{f" {subject.upper()} ":=^80}{os.linesep}')
if data is not None:
write_data: str
if isinstance(data, bytes):
write_data = data.decode()
else:
write_data = data
handler.writelines([write_data + os.linesep])
append_report("Raiden version", json.dumps(get_system_spec()))
append_report("Raiden log")
def print_step(description: str, error: bool = False) -> None:
nonlocal step
step += 1
click.echo(
"{} {}".format(
click.style(f"[{step}/{step_count}]", fg="blue"),
click.style(description, fg="green" if not error else "red"),
),
file=stdout,
)
contracts_version = RAIDEN_CONTRACT_VERSION
try:
free_port_generator = get_free_port()
ethereum_nodes = None
datadir = mkdtemp()
testchain_manager: ContextManager[Dict[
str, Any]] = setup_testchain_for_smoketest(
eth_client=eth_client,
print_step=print_step,
free_port_generator=free_port_generator,
base_datadir=datadir,
base_logdir=datadir,
)
matrix_manager: ContextManager[
List[ParsedURL]] = setup_matrix_for_smoketest(
print_step=print_step,
free_port_generator=free_port_generator,
broadcast_rooms_aliases=[
make_room_alias(NETWORKNAME_TO_ID["smoketest"],
DISCOVERY_DEFAULT_ROOM)
],
)
# Do not redirect the stdout on a debug session, otherwise the REPL
# will also be redirected
if debug:
stdout_manager = contextlib.nullcontext()
else:
stdout_manager = contextlib.redirect_stdout(raiden_stdout)
with stdout_manager, testchain_manager as testchain, matrix_manager as server_urls:
result = setup_raiden(
transport=transport,
matrix_server=matrix_server,
print_step=print_step,
contracts_version=contracts_version,
eth_client=testchain["eth_client"],
eth_rpc_endpoint=testchain["eth_rpc_endpoint"],
web3=testchain["web3"],
base_datadir=testchain["base_datadir"],
keystore=testchain["keystore"],
)
args = result["args"]
contract_addresses = result["contract_addresses"]
ethereum_nodes = testchain["node_executors"]
token = result["token"]
port = next(free_port_generator)
args["api_address"] = f"localhost:{port}"
args["config"] = deepcopy(App.DEFAULT_CONFIG)
args["environment_type"] = environment_type
args["extra_config"] = {
"transport": {
"matrix": {
"available_servers": server_urls
}
}
}
args["one_to_n_contract_address"] = "0x" + "1" * 40
args["routing_mode"] = RoutingMode.PRIVATE
args["flat_fee"] = ()
args["proportional_fee"] = ()
args["proportional_imbalance_fee"] = ()
for option_ in run.params:
if option_.name in args.keys():
args[option_.name] = option_.process_value(
ctx, args[option_.name])
else:
args[option_.name] = option_.default
try:
run_smoketest(
print_step=print_step,
args=args,
contract_addresses=contract_addresses,
token=token,
)
finally:
if ethereum_nodes:
for node_executor in ethereum_nodes:
node = node_executor.process
node.send_signal(signal.SIGINT)
try:
node.wait(10)
except TimeoutExpired:
print_step(
"Ethereum node shutdown unclean, check log!",
error=True)
node.kill()
if isinstance(node_executor.stdio, tuple):
logfile = node_executor.stdio[1]
logfile.flush()
logfile.seek(0)
append_report("Ethereum Node log output",
logfile.read())
append_report("Raiden Node stdout", raiden_stdout.getvalue())
except: # noqa pylint: disable=bare-except
if debug:
import pdb
pdb.post_mortem() # pylint: disable=no-member
error = traceback.format_exc()
append_report("Smoketest execution error", error)
print_step("Smoketest execution error", error=True)
success = False
else:
print_step(f"Smoketest successful")
success = True
if not success:
sys.exit(1)
def run(ctx: Context, **kwargs: Any) -> None:
# pylint: disable=too-many-locals,too-many-branches,too-many-statements
if kwargs["config_file"]:
apply_config_file(run, kwargs, ctx)
configure_logging(
kwargs["log_config"],
log_json=kwargs["log_json"],
log_file=kwargs["log_file"],
disable_debug_logfile=kwargs["disable_debug_logfile"],
debug_log_file_path=kwargs["debug_logfile_path"],
)
flamegraph = kwargs.pop("flamegraph", None)
switch_tracing = kwargs.pop("switch_tracing", None)
profiler = None
switch_monitor = None
enable_gevent_monitoring_signal()
if flamegraph: # pragma: no cover
windows_not_supported("flame graph")
from raiden.utils.profiling.sampler import FlameGraphCollector, TraceSampler
os.makedirs(flamegraph, exist_ok=True)
now = datetime.datetime.now().isoformat()
address = to_checksum_address(kwargs["address"])
stack_path = os.path.join(flamegraph, f"{address}_{now}_stack.data")
stack_stream = open(stack_path, "w")
flame = FlameGraphCollector(stack_stream)
profiler = TraceSampler(flame)
if switch_tracing is True: # pragma: no cover
windows_not_supported("switch tracing")
from raiden.utils.profiling.greenlets import SwitchMonitoring
switch_monitor = SwitchMonitoring()
if kwargs["environment_type"] == Environment.DEVELOPMENT:
IDLE.enable()
memory_logger = None
log_memory_usage_interval = kwargs.pop("log_memory_usage_interval", 0)
if log_memory_usage_interval > 0: # pragma: no cover
windows_not_supported("memory usage logging")
from raiden.utils.profiling.memory import MemoryLogger
memory_logger = MemoryLogger(log_memory_usage_interval)
memory_logger.start()
if ctx.invoked_subcommand is not None:
# Pass parsed args on to subcommands.
ctx.obj = kwargs
return
raiden_version = get_system_spec()["raiden"]
click.secho(f"Welcome to Raiden, version {raiden_version}!", fg="green")
click.secho(
textwrap.dedent("""\
+------------------------------------------------------------------------+
| This is a Beta version of experimental open source software released |
| as a test version under an MIT license and may contain errors and/or |
| bugs. No guarantee or representation whatsoever is made regarding its |
| suitability (or its use) for any purpose or regarding its compliance |
| with any applicable laws and regulations. Use of the software is at |
| your own risk and discretion and by using the software you warrant and |
| represent that you have read this disclaimer, understand its contents, |
| assume all risk related thereto and hereby release, waive, discharge |
| and covenant not to hold liable Brainbot Labs Establishment or any of |
| its officers, employees or affiliates from and for any direct or |
| indirect damage resulting from the software or the use thereof. |
| Such to the extent as permissible by applicable laws and regulations. |
| |
| Privacy warning: Please be aware, that by using the Raiden Client, |
| among others your Ethereum address, channels, channel deposits, |
| settlements and the Ethereum address of your channel counterparty will |
| be stored on the Ethereum chain, i.e. on servers of Ethereum node |
| operators and ergo are to a certain extent publicly available. The |
| same might also be stored on systems of parties running Raiden nodes |
| connected to the same token network. Data present in the Ethereum |
| chain is very unlikely to be able to be changed, removed or deleted |
| from the public arena. |
| |
| Also be aware, that data on individual Raiden token transfers will be |
| made available via the Matrix protocol to the recipient, |
| intermediating nodes of a specific transfer as well as to the Matrix |
| server operators, see Raiden Transport Specification. |
+------------------------------------------------------------------------+"""
),
fg="yellow",
)
if not kwargs["accept_disclaimer"]:
click.confirm(
"\nHave you read, understood and hereby accept the above "
"disclaimer and privacy warning?",
abort=True,
)
# Name used in the exception handlers, make sure the kwargs contains the
# key with the correct name by always running it.
name_or_id = ID_TO_CHAINNAME.get(kwargs["chain_id"], kwargs["chain_id"])
# TODO:
# - Ask for confirmation to quit if there are any locked transfers that did
# not timeout.
try:
run_services(kwargs)
except KeyboardInterrupt:
# The user requested a shutdown. Assume that if the exception
# propagated all the way to the top-level everything was shutdown
# properly.
#
# Notes about edge cases:
# - It could happen the exception was handled somewhere else in the
# code, and did not reach the top-level, ideally that should result in
# an exit with a non-zero code, but currently there is not way to
# detect that.
# - Just because the exception reached main, it doesn't mean that all
# services were properly cleaned up. Ideally at this stage we should
# run extra code to verify the state of the main services, and if any
# of the is not properly shutdown exit with a non-zero code.
pass
except (ReplacementTransactionUnderpriced, EthereumNonceTooLow) as ex:
click.secho(
f"{ex}. Please make sure that this Raiden node is the "
f"only user of the selected account",
fg="red",
)
sys.exit(ReturnCode.ETH_ACCOUNT_ERROR)
except (ConnectionError, ConnectTimeout, RequestsConnectionError,
ReadTimeoutError):
print(COMMUNICATION_ERROR.format(kwargs["eth_rpc_endpoint"]))
sys.exit(ReturnCode.GENERIC_COMMUNICATION_ERROR)
except EthNodeInterfaceError as e:
click.secho(str(e), fg="red")
sys.exit(ReturnCode.ETH_INTERFACE_ERROR)
except RaidenUnrecoverableError as ex:
write_stack_trace(ex)
sys.exit(ReturnCode.FATAL)
except APIServerPortInUseError as ex:
click.secho(
f"ERROR: API Address {ex} is in use. Use --api-address <host:port> "
f"to specify a different port.",
fg="red",
)
sys.exit(ReturnCode.PORT_ALREADY_IN_USE)
except (KeystoreAuthenticationError, KeystoreFileNotFound) as e:
click.secho(str(e), fg="red")
sys.exit(ReturnCode.ETH_ACCOUNT_ERROR)
except ConfigurationError as e:
click.secho(str(e), fg="red")
sys.exit(ReturnCode.RAIDEN_CONFIGURATION_ERROR)
except ContractCodeMismatch as e:
click.secho(
f"{e}. This may happen if Raiden is configured to use an "
f"unsupported version of the contracts.",
fg="red",
)
sys.exit(ReturnCode.SMART_CONTRACTS_CONFIGURATION_ERROR)
except AddressWithoutCode as e:
click.secho(
f"{e}. This may happen if an external ERC20 smart contract "
f"selfdestructed, or if the configured address is misconfigured, make "
f"sure the used address is not a normal account but a smart contract, "
f"and that it is deployed to {name_or_id}.",
fg="red",
)
sys.exit(ReturnCode.SMART_CONTRACTS_CONFIGURATION_ERROR)
except filelock.Timeout:
click.secho(
f"FATAL: Another Raiden instance already running for account "
f"{to_checksum_address(kwargs['address'])} on network id {name_or_id}",
fg="red",
)
sys.exit(ReturnCode.RAIDEN_CONFIGURATION_ERROR)
except Exception as ex:
write_stack_trace(ex)
sys.exit(ReturnCode.FATAL)
finally: # pragma: no cover
# teardown order is important because of side-effects, both the
# switch_monitor and profiler could use the tracing api, for the
# teardown code to work correctly the teardown has to be done in the
# reverse order of the initialization.
if switch_monitor is not None:
switch_monitor.stop()
if memory_logger is not None:
memory_logger.stop()
if profiler is not None:
profiler.stop()
