def restart_app(app: App) -> App:
new_transport = MatrixTransport(
config=app.raiden.config.transport,
environment=app.raiden.config.environment_type)
raiden_event_handler = RaidenEventHandler()
hold_handler = HoldRaidenEventHandler(raiden_event_handler)
app = App(
config=app.config,
rpc_client=app.raiden.rpc_client,
proxy_manager=app.raiden.proxy_manager,
query_start_block=BlockNumber(0),
default_one_to_n_address=app.raiden.default_one_to_n_address,
default_registry=app.raiden.default_registry,
default_secret_registry=app.raiden.default_secret_registry,
default_service_registry=app.raiden.default_service_registry,
default_msc_address=app.raiden.default_msc_address,
transport=new_transport,
raiden_event_handler=hold_handler,
message_handler=MessageHandler(),
routing_mode=RoutingMode.PRIVATE,
)
app.start()
return app
def restart_app(app):
host_port = (
app.raiden.config['transport']['udp']['host'],
app.raiden.config['transport']['udp']['port'],
)
socket = server._udp_socket(host_port) # pylint: disable=protected-access
new_transport = UDPTransport(
app.discovery,
socket,
app.raiden.transport.throttle_policy,
app.raiden.config['transport']['udp'],
)
app = App(
config=app.config,
chain=app.raiden.chain,
query_start_block=0,
default_registry=app.raiden.default_registry,
default_secret_registry=app.raiden.default_secret_registry,
transport=new_transport,
raiden_event_handler=RaidenEventHandler(),
discovery=app.raiden.discovery,
)
app.start()
return app
def restart_app(app):
host_port = (
app.raiden.config['transport']['udp']['host'],
app.raiden.config['transport']['udp']['port'],
)
socket = server._udp_socket(host_port) # pylint: disable=protected-access
new_transport = UDPTransport(
app.raiden.address,
app.discovery,
socket,
app.raiden.transport.throttle_policy,
app.raiden.config['transport']['udp'],
)
app = App(
config=app.config,
chain=app.raiden.chain,
query_start_block=0,
default_registry=app.raiden.default_registry,
default_secret_registry=app.raiden.default_secret_registry,
transport=new_transport,
raiden_event_handler=RaidenEventHandler(),
message_handler=MessageHandler(),
discovery=app.raiden.discovery,
)
app.start()
return app
def test_initialize_wal_throws_when_lock_is_taken(raiden_network: List[App]):
"""Raiden must throw a proper exception when the filelock of the DB is already taken.
Test for https://github.com/raiden-network/raiden/issues/6079
"""
app0, _ = raiden_network
# Start a second app, that should throw an expection, as the lock is already taken
app0_2 = App(
config=app0.config,
rpc_client=app0.raiden.rpc_client,
proxy_manager=app0.raiden.proxy_manager,
query_start_block=BlockNumber(0),
default_registry=app0.raiden.default_registry,
default_secret_registry=app0.raiden.default_secret_registry,
default_service_registry=app0.raiden.default_service_registry,
default_user_deposit=app0.raiden.default_user_deposit,
default_one_to_n_address=app0.raiden.default_one_to_n_address,
default_msc_address=app0.raiden.default_msc_address,
transport=app0.raiden.transport,
raiden_event_handler=RaidenEventHandler(),
message_handler=MessageHandler(),
routing_mode=RoutingMode.PRIVATE,
)
with pytest.raises(RaidenUnrecoverableError):
app0_2.start()
def restart_app(app):
host_port = (
app.raiden.config["transport"]["udp"]["host"],
app.raiden.config["transport"]["udp"]["port"],
)
socket = server._udp_socket(host_port) # pylint: disable=protected-access
new_transport = UDPTransport(
app.raiden.address,
app.discovery,
socket,
app.raiden.transport.throttle_policy,
app.raiden.config["transport"]["udp"],
)
app = App(
config=app.config,
chain=app.raiden.chain,
query_start_block=0,
default_one_to_n_address=app.raiden.default_one_to_n_address,
default_registry=app.raiden.default_registry,
default_secret_registry=app.raiden.default_secret_registry,
default_service_registry=app.raiden.default_service_registry,
transport=new_transport,
raiden_event_handler=RaidenEventHandler(),
message_handler=MessageHandler(),
discovery=app.raiden.discovery,
)
app.start()
return app
def run_test_regression_transport_global_queues_are_initialized_on_restart_for_services(
raiden_network, number_of_nodes, token_addresses, network_wait,
user_deposit_address):
app0, app1 = raiden_network
app0.config["services"]["monitoring_enabled"] = True
# Send a transfer to make sure the state has a balance proof
# to publish to the global matrix rooms
token_address = token_addresses[0]
amount = 10
transfer(
initiator_app=app1,
target_app=app0,
token_address=token_address,
amount=amount,
identifier=1,
timeout=network_wait * number_of_nodes,
)
app0.stop()
transport = MatrixTransport(app0.config["transport"]["matrix"])
transport.send_async = Mock()
transport._send_raw = Mock()
old_start_transport = transport.start
# Check that the queue is populated before the transport sends it and empties the queue
def start_transport(*args, **kwargs):
# Before restart the transport's global message queue should be initialized
# There should be 2 messages in the global queue.
# 1 for the PFS and the other for MS
assert len(transport._global_send_queue) == 2
# No other messages were sent at this point
transport.send_async.assert_not_called()
transport._send_raw.assert_not_called()
old_start_transport(*args, **kwargs)
transport.start = start_transport
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
app0_restart = App(
config=app0.config,
chain=app0.raiden.chain,
query_start_block=0,
default_registry=app0.raiden.default_registry,
default_one_to_n_address=app0.raiden.default_one_to_n_address,
default_secret_registry=app0.raiden.default_secret_registry,
default_service_registry=app0.raiden.default_service_registry,
transport=transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
discovery=app0.raiden.discovery,
user_deposit=app0.raiden.chain.user_deposit(user_deposit_address),
)
app0_restart.start()
def tps_run(host, port, config, privatekey, rpc_server, registry_address,
token_address, transfer_amount, parallel):
# pylint: disable=too-many-locals,too-many-arguments
ourprivkey, _ = hostport_to_privkeyaddr(host, port)
rpc_connection = rpc_server.split(':')
rpc_connection = (rpc_connection[0], int(rpc_connection[1]))
with codecs.open(config, encoding='utf8') as handler:
config = yaml.load(handler)
config['host'] = host
config['port'] = port
config['privkey'] = ourprivkey
rpc_connection = rpc_server.split(':')
host, port = (rpc_connection[0], int(rpc_connection[1]))
rpc_client = JSONRPCClient(
privkey=privatekey,
host=host,
port=port,
print_communication=False,
)
blockchain_service = BlockChainService(
privatekey,
registry_address,
rpc_client,
)
discovery = Discovery()
found_ouraddress = False
for node in config['nodes']:
_, address = hostport_to_privkeyaddr(node['host'], node['port'])
discovery.register(address, node['host'], node['port'])
if host == node['host'] and str(port) == node['port']:
found_ouraddress = True
if not found_ouraddress:
print('We are not registered in the configuration file')
sys.exit(1)
app = App(config, blockchain_service, discovery)
for _ in range(parallel):
gevent.spawn(random_transfer, app, token_address, transfer_amount)
# wait for interrupt
event = gevent.event.Event()
gevent.signal(signal.SIGQUIT, event.set)
gevent.signal(signal.SIGTERM, event.set)
gevent.signal(signal.SIGINT, event.set)
event.wait()
app.stop()
def tps_run(host, port, config, rpc_server, channelmanager_address,
asset_address, transfer_amount, parallel):
# pylint: disable=too-many-locals,too-many-arguments
ourprivkey, _ = hostport_to_privkeyaddr(host, port)
rpc_connection = rpc_server.split(':')
rpc_connection = (rpc_connection[0], int(rpc_connection[1]))
with codecs.open(config, encoding='utf8') as handler:
config = yaml.load(handler)
config['host'] = host
config['port'] = port
config['privkey'] = ourprivkey
blockchain_service = BlockChainService(rpc_server, channelmanager_address)
discovery = Discovery()
found_ouraddress = False
for node in config['nodes']:
_, address = hostport_to_privkeyaddr(node['host'], node['port'])
discovery.register(address, node['host'], node['port'])
if host == node['host'] and str(port) == node['port']:
found_ouraddress = True
if not found_ouraddress:
print('We are not registered in the configuration file')
sys.exit(1)
app = App(config, blockchain_service, discovery)
for asset_address in blockchain_service.asset_addresses:
all_netting_contracts = blockchain_service.nettingaddresses_by_asset_participant(
asset,
app.raiden.address,
)
for netting_contract_address in all_netting_contracts:
app.raiden.setup_channel(
asset,
netting_contract_address,
app.config['reveal_timeout'],
)
for _ in range(parallel):
gevent.spawn(random_transfer, app, asset_address, transfer_amount)
# wait for interrupt
event = gevent.event.Event()
gevent.signal(signal.SIGQUIT, event.set)
gevent.signal(signal.SIGTERM, event.set)
gevent.signal(signal.SIGINT, event.set)
event.wait()
app.stop()
def mk_app(chain, discovery, transport_class, port, host='127.0.0.1'):
''' Instantiates an Raiden app with the given configuration. '''
config = copy.deepcopy(App.default_config)
config['port'] = port
config['host'] = host
config['privkey'] = sha3('{}:{}'.format(host, config['port']))
return App(config, chain, discovery, transport_class)
def create_app(
privatekey_bin,
chain,
discovery,
transport_class,
send_ping_time,
max_unresponsive_time,
port,
reveal_timeout,
settle_timeout,
database_path,
host='127.0.0.1',
):
''' Instantiates an Raiden app with the given configuration. '''
config = copy.deepcopy(App.default_config)
config['port'] = port
config['host'] = host
config['privatekey_hex'] = privatekey_bin.encode('hex')
config['send_ping_time'] = send_ping_time
config['max_unresponsive_time'] = max_unresponsive_time
config['reveal_timeout'] = reveal_timeout
config['settle_timeout'] = settle_timeout
config['database_path'] = database_path
app = App(
config,
chain,
discovery,
transport_class,
)
app.raiden.protocol.transport.throttle_policy = DummyPolicy()
return app
def test_recovery_blockchain_events(raiden_network, restart_node,
token_addresses, network_wait):
""" Close one of the two raiden apps that have a channel between them,
have the counterparty close the channel and then make sure the restarted
app sees the change
"""
app0, app1 = raiden_network
token_address = token_addresses[0]
app0.raiden.stop()
new_transport = MatrixTransport(
config=app0.raiden.config.transport,
environment=app0.raiden.config.environment_type)
app1_api = RaidenAPI(app1.raiden)
app1_api.channel_close(
registry_address=app0.raiden.default_registry.address,
token_address=token_address,
partner_address=app0.raiden.address,
)
app0.stop()
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
app0_restart = App(
config=app0.config,
rpc_client=app0.raiden.rpc_client,
proxy_manager=app0.raiden.proxy_manager,
query_start_block=BlockNumber(0),
default_registry=app0.raiden.default_registry,
default_one_to_n_address=app0.raiden.default_one_to_n_address,
default_secret_registry=app0.raiden.default_secret_registry,
default_service_registry=app0.raiden.default_service_registry,
default_msc_address=app0.raiden.default_msc_address,
transport=new_transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
routing_mode=RoutingMode.PRIVATE,
)
del app0 # from here on the app0_restart should be used
restart_node(app0_restart)
wal = app0_restart.raiden.wal
assert wal
# wait for the nodes' healthcheck to update the network statuses
waiting.wait_for_healthy(app0_restart.raiden, app1.raiden.address,
network_wait)
waiting.wait_for_healthy(app1.raiden, app0_restart.raiden.address,
network_wait)
restarted_state_changes = wal.storage.get_statechanges_by_range(
RANGE_ALL_STATE_CHANGES)
assert search_for_item(restarted_state_changes,
ContractReceiveChannelClosed, {})
def create_apps(blockchain_services, endpoint_discovery_services,
registry_address, raiden_udp_ports, transport_class,
reveal_timeout, settle_timeout, database_paths, retry_interval,
retries_before_backoff, throttle_capacity, throttle_fill_rate,
nat_invitation_timeout, nat_keepalive_retries,
nat_keepalive_timeout):
""" Create the apps."""
# pylint: disable=too-many-locals
services = zip(blockchain_services, endpoint_discovery_services)
apps = []
for idx, (blockchain, discovery) in enumerate(services):
port = raiden_udp_ports[idx]
private_key = blockchain.private_key
nodeid = privatekey_to_address(private_key)
host = '127.0.0.1'
discovery.register(nodeid, host, port)
config = {
'host': host,
'port': port,
'external_ip': host,
'external_port': port,
'privatekey_hex': hexlify(private_key),
'reveal_timeout': reveal_timeout,
'settle_timeout': settle_timeout,
'database_path': database_paths[idx],
'protocol': {
'retry_interval': retry_interval,
'retries_before_backoff': retries_before_backoff,
'throttle_capacity': throttle_capacity,
'throttle_fill_rate': throttle_fill_rate,
'nat_invitation_timeout': nat_invitation_timeout,
'nat_keepalive_retries': nat_keepalive_retries,
'nat_keepalive_timeout': nat_keepalive_timeout,
},
'rpc': True,
'console': False,
}
copy = App.DEFAULT_CONFIG.copy()
copy.update(config)
registry = blockchain.registry(registry_address)
app = App(
copy,
blockchain,
registry,
discovery,
transport_class,
)
app.raiden.protocol.transport.throttle_policy = DummyPolicy()
apps.append(app)
return apps
def create_app(privatekey_bin,
chain,
discovery,
transport_class,
port,
host='127.0.0.1'):
''' Instantiates an Raiden app with the given configuration. '''
config = copy.deepcopy(App.default_config)
config['port'] = port
config['host'] = host
config['privatekey_hex'] = privatekey_bin.encode('hex')
return App(
config,
chain,
discovery,
transport_class,
)
def run_app(
address,
keystore_path,
gas_price,
eth_rpc_endpoint,
tokennetwork_registry_contract_address,
secret_registry_contract_address,
endpoint_registry_contract_address,
listen_address,
mapped_socket,
max_unresponsive_time,
api_address,
rpc,
sync_check,
console,
password_file,
web_ui,
datadir,
transport,
matrix_server,
network_id,
environment_type,
unrecoverable_error_should_crash,
pathfinding_service_address,
pathfinding_max_paths,
config=None,
extra_config=None,
**kwargs,
):
# pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument
from raiden.app import App
_assert_sql_version()
if transport == 'udp' and not mapped_socket:
raise RuntimeError('Missing socket')
if datadir is None:
datadir = os.path.join(os.path.expanduser('~'), '.raiden')
address_hex = to_normalized_address(address) if address else None
address_hex, privatekey_bin = prompt_account(address_hex, keystore_path, password_file)
address = to_canonical_address(address_hex)
(listen_host, listen_port) = split_endpoint(listen_address)
(api_host, api_port) = split_endpoint(api_address)
config['transport']['udp']['host'] = listen_host
config['transport']['udp']['port'] = listen_port
config['console'] = console
config['rpc'] = rpc
config['web_ui'] = rpc and web_ui
config['api_host'] = api_host
config['api_port'] = api_port
if mapped_socket:
config['socket'] = mapped_socket.socket
config['transport']['udp']['external_ip'] = mapped_socket.external_ip
config['transport']['udp']['external_port'] = mapped_socket.external_port
config['transport_type'] = transport
config['transport']['matrix']['server'] = matrix_server
config['transport']['udp']['nat_keepalive_retries'] = DEFAULT_NAT_KEEPALIVE_RETRIES
timeout = max_unresponsive_time / DEFAULT_NAT_KEEPALIVE_RETRIES
config['transport']['udp']['nat_keepalive_timeout'] = timeout
config['privatekey_hex'] = encode_hex(privatekey_bin)
config['unrecoverable_error_should_crash'] = unrecoverable_error_should_crash
config['services']['pathfinding_service_address'] = pathfinding_service_address
config['services']['pathfinding_max_paths'] = pathfinding_max_paths
parsed_eth_rpc_endpoint = urlparse(eth_rpc_endpoint)
if not parsed_eth_rpc_endpoint.scheme:
eth_rpc_endpoint = f'http://{eth_rpc_endpoint}'
web3 = _setup_web3(eth_rpc_endpoint)
rpc_client = JSONRPCClient(
web3,
privatekey_bin,
gas_price_strategy=gas_price,
block_num_confirmations=DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS,
uses_infura='infura.io' in eth_rpc_endpoint,
)
blockchain_service = BlockChainService(
privatekey_bin=privatekey_bin,
jsonrpc_client=rpc_client,
# Not giving the contract manager here, but injecting it later
# since we first need blockchain service to calculate the network id
)
given_network_id = network_id
node_network_id = blockchain_service.network_id
known_given_network_id = given_network_id in ID_TO_NETWORKNAME
known_node_network_id = node_network_id in ID_TO_NETWORKNAME
if node_network_id != given_network_id:
if known_given_network_id and known_node_network_id:
click.secho(
f"The chosen ethereum network '{ID_TO_NETWORKNAME[given_network_id]}' "
f"differs from the ethereum client '{ID_TO_NETWORKNAME[node_network_id]}'. "
"Please update your settings.",
fg='red',
)
else:
click.secho(
f"The chosen ethereum network id '{given_network_id}' differs "
f"from the ethereum client '{node_network_id}'. "
"Please update your settings.",
fg='red',
)
sys.exit(1)
config['chain_id'] = given_network_id
# interpret the provided string argument
if environment_type == Environment.PRODUCTION:
# Safe configuration: restrictions for mainnet apply and matrix rooms have to be private
config['environment_type'] = Environment.PRODUCTION
config['transport']['matrix']['private_rooms'] = True
else:
config['environment_type'] = Environment.DEVELOPMENT
environment_type = config['environment_type']
print(f'Raiden is running in {environment_type.value.lower()} mode')
chain_config = {}
contract_addresses_known = False
contracts = dict()
contracts_version = 'pre_limits' if environment_type == Environment.DEVELOPMENT else None
config['contracts_path'] = contracts_precompiled_path(contracts_version)
if node_network_id in ID_TO_NETWORKNAME and ID_TO_NETWORKNAME[node_network_id] != 'smoketest':
deployment_data = get_contracts_deployed(node_network_id, contracts_version)
not_allowed = ( # for now we only disallow mainnet with test configuration
network_id == 1 and
environment_type == Environment.DEVELOPMENT
)
if not_allowed:
click.secho(
f'The chosen network ({ID_TO_NETWORKNAME[node_network_id]}) is not a testnet, '
'but the "development" environment was selected.\n'
'This is not allowed. Please start again with a safe environment setting '
'(--environment production).',
fg='red',
)
sys.exit(1)
contracts = deployment_data['contracts']
contract_addresses_known = True
blockchain_service.inject_contract_manager(ContractManager(config['contracts_path']))
if sync_check:
check_synced(blockchain_service, known_node_network_id)
contract_addresses_given = (
tokennetwork_registry_contract_address is not None and
secret_registry_contract_address is not None and
endpoint_registry_contract_address is not None
)
if not contract_addresses_given and not contract_addresses_known:
click.secho(
f"There are no known contract addresses for network id '{given_network_id}'. "
"Please provide them on the command line or in the configuration file.",
fg='red',
)
sys.exit(1)
try:
token_network_registry = blockchain_service.token_network_registry(
tokennetwork_registry_contract_address or to_canonical_address(
contracts[CONTRACT_TOKEN_NETWORK_REGISTRY]['address'],
),
)
except ContractVersionMismatch as e:
handle_contract_version_mismatch(e)
except AddressWithoutCode:
handle_contract_no_code('token network registry', tokennetwork_registry_contract_address)
except AddressWrongContract:
handle_contract_wrong_address(
'token network registry',
tokennetwork_registry_contract_address,
)
try:
secret_registry = blockchain_service.secret_registry(
secret_registry_contract_address or to_canonical_address(
contracts[CONTRACT_SECRET_REGISTRY]['address'],
),
)
except ContractVersionMismatch as e:
handle_contract_version_mismatch(e)
except AddressWithoutCode:
handle_contract_no_code('secret registry', secret_registry_contract_address)
except AddressWrongContract:
handle_contract_wrong_address('secret registry', secret_registry_contract_address)
database_path = os.path.join(
datadir,
f'node_{pex(address)}',
f'netid_{given_network_id}',
f'network_{pex(token_network_registry.address)}',
f'v{RAIDEN_DB_VERSION}_log.db',
)
config['database_path'] = database_path
print(
'\nYou are connected to the \'{}\' network and the DB path is: {}'.format(
ID_TO_NETWORKNAME.get(given_network_id, given_network_id),
database_path,
),
)
discovery = None
if transport == 'udp':
transport, discovery = _setup_udp(
config,
blockchain_service,
address,
contracts,
endpoint_registry_contract_address,
)
elif transport == 'matrix':
transport = _setup_matrix(config)
else:
raise RuntimeError(f'Unknown transport type "{transport}" given')
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
try:
if 'contracts' in chain_config:
start_block = chain_config['contracts']['TokenNetworkRegistry']['block_number']
else:
start_block = 0
raiden_app = App(
config=config,
chain=blockchain_service,
query_start_block=start_block,
default_registry=token_network_registry,
default_secret_registry=secret_registry,
transport=transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
discovery=discovery,
)
except RaidenError as e:
click.secho(f'FATAL: {e}', fg='red')
sys.exit(1)
try:
raiden_app.start()
except RuntimeError as e:
click.secho(f'FATAL: {e}', fg='red')
sys.exit(1)
except filelock.Timeout:
name_or_id = ID_TO_NETWORKNAME.get(given_network_id, given_network_id)
click.secho(
f'FATAL: Another Raiden instance already running for account {address_hex} on '
f'network id {name_or_id}',
fg='red',
)
sys.exit(1)
return raiden_app
def run_test_payment_statuses_are_restored(
raiden_network,
token_addresses,
network_wait,
):
app0, app1 = raiden_network
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
payment_network_id = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state,
payment_network_id,
token_address,
)
app0.event_handler = HoldRaidenEvent()
app0.event_handler.hold(SendSecretReveal, {})
# make a few transfers from app0 to app1
amount = 1
spent_amount = 7
identifier = 1
for identifier in range(spent_amount):
identifier = identifier + 1
payment_status = app0.raiden.mediated_transfer_async(
token_network_identifier=token_network_identifier,
amount=amount,
target=app1.raiden.address,
identifier=identifier,
)
assert payment_status.payment_identifier == identifier
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
app0_restart = App(
config=app0.config,
chain=app0.raiden.chain,
query_start_block=0,
default_registry=app0.raiden.default_registry,
default_secret_registry=app0.raiden.default_secret_registry,
default_service_registry=app0.raiden.default_service_registry,
transport=MatrixTransport(app0.raiden.config['transport']['matrix'], ),
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
discovery=app0.raiden.discovery,
)
app0.stop()
del app0 # from here on the app0_restart should be used
# stop app1 to make sure that we don't complete the transfers before our checks
app1.stop()
app0_restart.start()
# Check that the payment statuses were restored properly after restart
for identifier in range(spent_amount):
identifier = identifier + 1
mapping = app0_restart.raiden.targets_to_identifiers_to_statuses
status = mapping[app1.raiden.address][identifier]
assert status.amount == 1
assert status.payment_identifier == identifier
assert status.token_network_identifier == token_network_identifier
app1.start() # now that our checks are done start app1 again
waiting.wait_for_healthy(
app0_restart.raiden,
app1.raiden.address,
network_wait,
)
waiting.wait_for_payment_balance(
raiden=app1.raiden,
payment_network_id=payment_network_id,
token_address=token_address,
partner_address=app0_restart.raiden.address,
target_address=app1.raiden.address,
target_balance=spent_amount,
retry_timeout=network_wait,
)
# Check that payments are completed after both nodes come online after restart
for identifier in range(spent_amount):
assert raiden_events_search_for_item(
app0_restart.raiden,
EventPaymentSentSuccess,
{
'identifier': identifier + 1,
'amount': 1
},
)
def tps_run(
host,
port,
config,
privatekey,
rpc_server,
registry_address,
token_address,
transfer_amount,
parallel):
# pylint: disable=too-many-locals,too-many-arguments
ourprivkey, _ = hostport_to_privkeyaddr(host, port)
rpc_connection = rpc_server.split(':')
rpc_connection = (rpc_connection[0], int(rpc_connection[1]))
with codecs.open(config, encoding='utf8') as handler:
config = yaml.load(handler)
config['host'] = host
config['port'] = port
config['privkey'] = ourprivkey
rpc_connection = rpc_server.split(':')
host, port = (rpc_connection[0], int(rpc_connection[1]))
rpc_client = JSONRPCClient(
host,
port,
privatekey,
)
blockchain_service = BlockChainService(
privatekey,
rpc_client,
GAS_LIMIT,
GAS_PRICE,
)
discovery = Discovery()
found_ouraddress = False
for node in config['nodes']:
_, address = hostport_to_privkeyaddr(node['host'], node['port'])
discovery.register(address, node['host'], node['port'])
if host == node['host'] and str(port) == node['port']:
found_ouraddress = True
if not found_ouraddress:
print('We are not registered in the configuration file')
sys.exit(1)
app = App(
config,
blockchain_service,
discovery,
)
for _ in range(parallel):
gevent.spawn(random_transfer, app, token_address, transfer_amount)
# wait for interrupt
event = gevent.event.Event()
gevent.signal(signal.SIGQUIT, event.set)
gevent.signal(signal.SIGTERM, event.set)
gevent.signal(signal.SIGINT, event.set)
event.wait()
app.stop()
def run_app(
address,
keystore_path,
gas_price,
eth_rpc_endpoint,
tokennetwork_registry_contract_address,
secret_registry_contract_address,
service_registry_contract_address,
endpoint_registry_contract_address,
user_deposit_contract_address,
listen_address,
mapped_socket,
max_unresponsive_time,
api_address,
rpc,
sync_check,
console,
password_file,
web_ui,
datadir,
transport,
matrix_server,
network_id,
environment_type,
unrecoverable_error_should_crash,
pathfinding_service_address,
pathfinding_eth_address,
pathfinding_max_paths,
enable_monitoring,
resolver_endpoint,
routing_mode,
config=None,
extra_config=None,
**kwargs,
):
# pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument
from raiden.app import App
check_sql_version()
if transport == "udp" and not mapped_socket:
raise RuntimeError("Missing socket")
if datadir is None:
datadir = os.path.join(os.path.expanduser("~"), ".raiden")
account_manager = AccountManager(keystore_path)
check_has_accounts(account_manager)
if not address:
address_hex = prompt_account(account_manager)
else:
address_hex = to_normalized_address(address)
if password_file:
privatekey_bin = unlock_account_with_passwordfile(
account_manager=account_manager,
address_hex=address_hex,
password_file=password_file)
else:
privatekey_bin = unlock_account_with_passwordprompt(
account_manager=account_manager, address_hex=address_hex)
address = to_canonical_address(address_hex)
(listen_host, listen_port) = split_endpoint(listen_address)
(api_host, api_port) = split_endpoint(api_address)
config["transport"]["udp"]["host"] = listen_host
config["transport"]["udp"]["port"] = listen_port
config["console"] = console
config["rpc"] = rpc
config["web_ui"] = rpc and web_ui
config["api_host"] = api_host
config["api_port"] = api_port
config["resolver_endpoint"] = resolver_endpoint
if mapped_socket:
config["socket"] = mapped_socket.socket
config["transport"]["udp"]["external_ip"] = mapped_socket.external_ip
config["transport"]["udp"][
"external_port"] = mapped_socket.external_port
config["transport_type"] = transport
config["transport"]["matrix"]["server"] = matrix_server
config["transport"]["udp"][
"nat_keepalive_retries"] = DEFAULT_NAT_KEEPALIVE_RETRIES
timeout = max_unresponsive_time / DEFAULT_NAT_KEEPALIVE_RETRIES
config["transport"]["udp"]["nat_keepalive_timeout"] = timeout
config[
"unrecoverable_error_should_crash"] = unrecoverable_error_should_crash
config["services"]["pathfinding_max_paths"] = pathfinding_max_paths
config["services"]["monitoring_enabled"] = enable_monitoring
parsed_eth_rpc_endpoint = urlparse(eth_rpc_endpoint)
if not parsed_eth_rpc_endpoint.scheme:
eth_rpc_endpoint = f"http://{eth_rpc_endpoint}"
web3 = Web3(HTTPProvider(eth_rpc_endpoint))
check_ethereum_version(web3)
check_network_id(network_id, web3)
config["chain_id"] = network_id
setup_environment(config, environment_type)
contracts = setup_contracts_or_exit(config, network_id)
rpc_client = JSONRPCClient(
web3,
privatekey_bin,
gas_price_strategy=gas_price,
block_num_confirmations=DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS,
uses_infura="infura.io" in eth_rpc_endpoint,
)
blockchain_service = BlockChainService(jsonrpc_client=rpc_client,
contract_manager=ContractManager(
config["contracts_path"]))
if sync_check:
check_synced(blockchain_service)
proxies = setup_proxies_or_exit(
config=config,
tokennetwork_registry_contract_address=
tokennetwork_registry_contract_address,
secret_registry_contract_address=secret_registry_contract_address,
endpoint_registry_contract_address=endpoint_registry_contract_address,
user_deposit_contract_address=user_deposit_contract_address,
service_registry_contract_address=service_registry_contract_address,
blockchain_service=blockchain_service,
contracts=contracts,
routing_mode=routing_mode,
pathfinding_service_address=pathfinding_service_address,
pathfinding_eth_address=pathfinding_eth_address,
)
database_path = os.path.join(
datadir,
f"node_{pex(address)}",
f"netid_{network_id}",
f"network_{pex(proxies.token_network_registry.address)}",
f"v{RAIDEN_DB_VERSION}_log.db",
)
config["database_path"] = database_path
print("\nYou are connected to the '{}' network and the DB path is: {}".
format(ID_TO_NETWORKNAME.get(network_id, network_id), database_path))
discovery = None
if transport == "udp":
transport, discovery = setup_udp_or_exit(
config, blockchain_service, address, contracts,
endpoint_registry_contract_address)
elif transport == "matrix":
transport = _setup_matrix(config)
else:
raise RuntimeError(f'Unknown transport type "{transport}" given')
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
try:
start_block = 0
if "TokenNetworkRegistry" in contracts:
start_block = contracts["TokenNetworkRegistry"]["block_number"]
raiden_app = App(
config=config,
chain=blockchain_service,
query_start_block=start_block,
default_registry=proxies.token_network_registry,
default_secret_registry=proxies.secret_registry,
default_service_registry=proxies.service_registry,
transport=transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
discovery=discovery,
user_deposit=proxies.user_deposit,
)
except RaidenError as e:
click.secho(f"FATAL: {e}", fg="red")
sys.exit(1)
try:
raiden_app.start()
except RuntimeError as e:
click.secho(f"FATAL: {e}", fg="red")
sys.exit(1)
except filelock.Timeout:
name_or_id = ID_TO_NETWORKNAME.get(network_id, network_id)
click.secho(
f"FATAL: Another Raiden instance already running for account {address_hex} on "
f"network id {name_or_id}",
fg="red",
)
sys.exit(1)
return raiden_app
def test_recovery_happy_case(
raiden_network,
number_of_nodes,
deposit,
token_addresses,
network_wait,
skip_if_not_udp,
):
app0, app1, app2 = raiden_network
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
payment_network_id = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state,
payment_network_id,
token_address,
)
# make a few transfers from app0 to app2
amount = 1
spent_amount = deposit - 2
for _ in range(spent_amount):
mediated_transfer(
app0,
app2,
token_network_identifier,
amount,
timeout=network_wait * number_of_nodes,
)
app0.raiden.stop()
host_port = (app0.raiden.config['host'], app0.raiden.config['port'])
socket = server._udp_socket(host_port)
new_transport = UDPTransport(
app0.discovery,
socket,
app0.raiden.transport.throttle_policy,
app0.raiden.config['transport'],
)
app0_restart = App(
config=app0.config,
chain=app0.raiden.chain,
query_start_block=0,
default_registry=app0.raiden.default_registry,
default_secret_registry=app0.raiden.default_secret_registry,
transport=new_transport,
discovery=app0.raiden.discovery,
)
app0.stop()
del app0 # from here on the app0_restart should be used
assert_synched_channel_state(
token_network_identifier,
app0_restart,
deposit - spent_amount,
[],
app1,
deposit + spent_amount,
[],
)
assert_synched_channel_state(
token_network_identifier,
app1,
deposit - spent_amount,
[],
app2,
deposit + spent_amount,
[],
)
# wait for the nodes' healthcheck to update the network statuses
waiting.wait_for_healthy(
app0_restart.raiden,
app1.raiden.address,
network_wait,
)
waiting.wait_for_healthy(
app1.raiden,
app0_restart.raiden.address,
network_wait,
)
mediated_transfer(
app2,
app0_restart,
token_network_identifier,
amount,
timeout=network_wait * number_of_nodes * 2,
)
mediated_transfer(
app0_restart,
app2,
token_network_identifier,
amount,
timeout=network_wait * number_of_nodes * 2,
)
assert_synched_channel_state(
token_network_identifier,
app0_restart,
deposit - spent_amount,
[],
app1,
deposit + spent_amount,
[],
)
assert_synched_channel_state(
token_network_identifier,
app1,
deposit - spent_amount,
[],
app2,
deposit + spent_amount,
[],
)
def test_send_queued_messages( # pylint: disable=unused-argument
raiden_network, deposit, token_addresses, network_wait):
"""Test re-sending of undelivered messages on node restart"""
app0, app1 = raiden_network
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
token_network_registry_address = app0.raiden.default_registry.address
token_network_address = views.get_token_network_address_by_token_address(
chain_state, token_network_registry_address, token_address)
assert token_network_address
number_of_transfers = 7
amount_per_transfer = 1
total_transferred_amount = TokenAmount(amount_per_transfer *
number_of_transfers)
# Make sure none of the transfers will be sent before the restart
transfers = []
for secret_seed in range(number_of_transfers):
secret = make_secret(secret_seed)
secrethash = sha256_secrethash(secret)
transfers.append((create_default_identifier(), amount_per_transfer,
secret, secrethash))
app0.raiden.raiden_event_handler.hold(
SendLockedTransfer,
{"transfer": {
"lock": {
"secrethash": secrethash
}
}})
for identifier, amount, secret, _ in transfers:
app0.raiden.mediated_transfer_async(
token_network_address=token_network_address,
amount=amount,
target=app1.raiden.address,
identifier=identifier,
secret=secret,
)
app0.stop()
# Restart the app. The pending transfers must be processed.
new_transport = MatrixTransport(app0.raiden.config["transport"]["matrix"])
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
app0_restart = App(
config=app0.config,
rpc_client=app0.raiden.rpc_client,
proxy_manager=app0.raiden.proxy_manager,
query_start_block=BlockNumber(0),
default_registry=app0.raiden.default_registry,
default_secret_registry=app0.raiden.default_secret_registry,
default_service_registry=app0.raiden.default_service_registry,
default_one_to_n_address=app0.raiden.default_one_to_n_address,
default_msc_address=app0.raiden.default_msc_address,
transport=new_transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
routing_mode=RoutingMode.PRIVATE,
)
del app0
app0_restart.start()
# XXX: There is no synchronization among the app and the test, so it is
# possible between `start` and the check bellow that some of the transfers
# have completed, making it flaky.
#
# Make sure the transfers are in the queue and fail otherwise.
# chain_state = views.state_from_raiden(app0_restart.raiden)
# for _, _, _, secrethash in transfers:
# msg = "The secrethashes of the pending transfers must be in the queue after a restart."
# assert secrethash in chain_state.payment_mapping.secrethashes_to_task, msg
with watch_for_unlock_failures(*raiden_network):
exception = RuntimeError(
"Timeout while waiting for balance update for app0")
with gevent.Timeout(20, exception=exception):
waiting.wait_for_payment_balance(
raiden=app0_restart.raiden,
token_network_registry_address=token_network_registry_address,
token_address=token_address,
partner_address=app1.raiden.address,
target_address=app1.raiden.address,
target_balance=total_transferred_amount,
retry_timeout=network_wait,
)
exception = RuntimeError(
"Timeout while waiting for balance update for app1")
with gevent.Timeout(20, exception=exception):
waiting.wait_for_payment_balance(
raiden=app1.raiden,
token_network_registry_address=token_network_registry_address,
token_address=token_address,
partner_address=app0_restart.raiden.address,
target_address=app1.raiden.address,
target_balance=total_transferred_amount,
retry_timeout=network_wait,
)
assert_synced_channel_state(
token_network_address,
app0_restart,
deposit - total_transferred_amount,
[],
app1,
deposit + total_transferred_amount,
[],
)
new_transport.stop()
def run_app(
address,
keystore_path,
gas_price,
eth_rpc_endpoint,
tokennetwork_registry_contract_address,
secret_registry_contract_address,
endpoint_registry_contract_address,
listen_address,
mapped_socket,
max_unresponsive_time,
api_address,
rpc,
sync_check,
console,
password_file,
web_ui,
datadir,
transport,
matrix_server,
network_id,
environment_type,
unrecoverable_error_should_crash,
pathfinding_service_address,
config=None,
extra_config=None,
**kwargs,
):
# pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument
from raiden.app import App
_assert_sql_version()
if transport == 'udp' and not mapped_socket:
raise RuntimeError('Missing socket')
if datadir is None:
datadir = os.path.join(os.path.expanduser('~'), '.raiden')
address_hex = to_normalized_address(address) if address else None
address_hex, privatekey_bin = prompt_account(address_hex, keystore_path,
password_file)
address = to_canonical_address(address_hex)
(listen_host, listen_port) = split_endpoint(listen_address)
(api_host, api_port) = split_endpoint(api_address)
config['transport']['udp']['host'] = listen_host
config['transport']['udp']['port'] = listen_port
config['console'] = console
config['rpc'] = rpc
config['web_ui'] = rpc and web_ui
config['api_host'] = api_host
config['api_port'] = api_port
if mapped_socket:
config['socket'] = mapped_socket.socket
config['transport']['udp']['external_ip'] = mapped_socket.external_ip
config['transport']['udp'][
'external_port'] = mapped_socket.external_port
config['transport_type'] = transport
config['transport']['matrix']['server'] = matrix_server
config['transport']['udp'][
'nat_keepalive_retries'] = DEFAULT_NAT_KEEPALIVE_RETRIES
timeout = max_unresponsive_time / DEFAULT_NAT_KEEPALIVE_RETRIES
config['transport']['udp']['nat_keepalive_timeout'] = timeout
config['privatekey_hex'] = encode_hex(privatekey_bin)
config[
'unrecoverable_error_should_crash'] = unrecoverable_error_should_crash
config['services'][
'pathfinding_service_address'] = pathfinding_service_address
parsed_eth_rpc_endpoint = urlparse(eth_rpc_endpoint)
if not parsed_eth_rpc_endpoint.scheme:
eth_rpc_endpoint = f'http://{eth_rpc_endpoint}'
web3 = _setup_web3(eth_rpc_endpoint)
rpc_client = JSONRPCClient(
web3,
privatekey_bin,
gas_price_strategy=gas_price,
block_num_confirmations=DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS,
uses_infura='infura.io' in eth_rpc_endpoint,
)
blockchain_service = BlockChainService(
privatekey_bin=privatekey_bin,
jsonrpc_client=rpc_client,
# Not giving the contract manager here, but injecting it later
# since we first need blockchain service to calculate the network id
)
given_network_id = network_id
node_network_id = blockchain_service.network_id
known_given_network_id = given_network_id in ID_TO_NETWORKNAME
known_node_network_id = node_network_id in ID_TO_NETWORKNAME
if node_network_id != given_network_id:
if known_given_network_id and known_node_network_id:
click.secho(
f"The chosen ethereum network '{ID_TO_NETWORKNAME[given_network_id]}' "
f"differs from the ethereum client '{ID_TO_NETWORKNAME[node_network_id]}'. "
"Please update your settings.",
fg='red',
)
else:
click.secho(
f"The chosen ethereum network id '{given_network_id}' differs "
f"from the ethereum client '{node_network_id}'. "
"Please update your settings.",
fg='red',
)
sys.exit(1)
config['chain_id'] = given_network_id
# interpret the provided string argument
if environment_type == Environment.PRODUCTION:
# Safe configuration: restrictions for mainnet apply and matrix rooms have to be private
config['environment_type'] = Environment.PRODUCTION
config['transport']['matrix']['private_rooms'] = True
else:
config['environment_type'] = Environment.DEVELOPMENT
environment_type = config['environment_type']
print(f'Raiden is running in {environment_type.value.lower()} mode')
chain_config = {}
contract_addresses_known = False
contracts = dict()
contracts_version = 'pre_limits' if environment_type == Environment.DEVELOPMENT else None
config['contracts_path'] = contracts_precompiled_path(contracts_version)
if node_network_id in ID_TO_NETWORKNAME and ID_TO_NETWORKNAME[
node_network_id] != 'smoketest':
deployment_data = get_contracts_deployed(node_network_id,
contracts_version)
not_allowed = ( # for now we only disallow mainnet with test configuration
network_id == 1 and environment_type == Environment.DEVELOPMENT)
if not_allowed:
click.secho(
f'The chosen network ({ID_TO_NETWORKNAME[node_network_id]}) is not a testnet, '
'but the "development" environment was selected.\n'
'This is not allowed. Please start again with a safe environment setting '
'(--environment production).',
fg='red',
)
sys.exit(1)
contracts = deployment_data['contracts']
contract_addresses_known = True
blockchain_service.inject_contract_manager(
ContractManager(config['contracts_path']))
if sync_check:
check_synced(blockchain_service, known_node_network_id)
contract_addresses_given = (
tokennetwork_registry_contract_address is not None
and secret_registry_contract_address is not None
and endpoint_registry_contract_address is not None)
if not contract_addresses_given and not contract_addresses_known:
click.secho(
f"There are no known contract addresses for network id '{given_network_id}'. "
"Please provide them on the command line or in the configuration file.",
fg='red',
)
sys.exit(1)
try:
token_network_registry = blockchain_service.token_network_registry(
tokennetwork_registry_contract_address or to_canonical_address(
contracts[CONTRACT_TOKEN_NETWORK_REGISTRY]['address'], ), )
except ContractVersionMismatch as e:
handle_contract_version_mismatch(e)
except AddressWithoutCode:
handle_contract_no_code('token network registry',
tokennetwork_registry_contract_address)
except AddressWrongContract:
handle_contract_wrong_address(
'token network registry',
tokennetwork_registry_contract_address,
)
try:
secret_registry = blockchain_service.secret_registry(
secret_registry_contract_address or to_canonical_address(
contracts[CONTRACT_SECRET_REGISTRY]['address'], ), )
except ContractVersionMismatch as e:
handle_contract_version_mismatch(e)
except AddressWithoutCode:
handle_contract_no_code('secret registry',
secret_registry_contract_address)
except AddressWrongContract:
handle_contract_wrong_address('secret registry',
secret_registry_contract_address)
database_path = os.path.join(
datadir,
f'node_{pex(address)}',
f'netid_{given_network_id}',
f'network_{pex(token_network_registry.address)}',
f'v{RAIDEN_DB_VERSION}_log.db',
)
config['database_path'] = database_path
print(
'\nYou are connected to the \'{}\' network and the DB path is: {}'.
format(
ID_TO_NETWORKNAME.get(given_network_id, given_network_id),
database_path,
), )
discovery = None
if transport == 'udp':
transport, discovery = _setup_udp(
config,
blockchain_service,
address,
contracts,
endpoint_registry_contract_address,
)
elif transport == 'matrix':
transport = _setup_matrix(config)
else:
raise RuntimeError(f'Unknown transport type "{transport}" given')
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
try:
if 'contracts' in chain_config:
start_block = chain_config['contracts']['TokenNetworkRegistry'][
'block_number']
else:
start_block = 0
raiden_app = App(
config=config,
chain=blockchain_service,
query_start_block=start_block,
default_registry=token_network_registry,
default_secret_registry=secret_registry,
transport=transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
discovery=discovery,
)
except RaidenError as e:
click.secho(f'FATAL: {e}', fg='red')
sys.exit(1)
try:
raiden_app.start()
except RuntimeError as e:
click.secho(f'FATAL: {e}', fg='red')
sys.exit(1)
except filelock.Timeout:
name_or_id = ID_TO_NETWORKNAME.get(given_network_id, given_network_id)
click.secho(
f'FATAL: Another Raiden instance already running for account {address_hex} on '
f'network id {name_or_id}',
fg='red',
)
sys.exit(1)
return raiden_app
def run(
privatekey,
registry_contract_address,
secret_registry_contract_address,
discovery_contract_address,
listen_address,
structlog,
logfile,
scenario,
stage_prefix,
): # pylint: disable=unused-argument
# TODO: only enabled structlog on "initiators"
structlog.configure(structlog, log_file=logfile)
(listen_host, listen_port) = split_endpoint(listen_address)
config = App.DEFAULT_CONFIG.copy()
config['host'] = listen_host
config['port'] = listen_port
config['privatekey_hex'] = privatekey
privatekey_bin = decode_hex(privatekey)
rpc_client = JSONRPCClient(
'127.0.0.1',
8545,
privatekey_bin,
)
blockchain_service = BlockChainService(
privatekey_bin,
rpc_client,
GAS_PRICE,
)
discovery = ContractDiscovery(
blockchain_service,
decode_hex(discovery_contract_address),
)
registry = blockchain_service.registry(
registry_contract_address,
)
secret_registry = blockchain_service.secret_registry(
secret_registry_contract_address,
)
throttle_policy = TokenBucket(
config['protocol']['throttle_capacity'],
config['protocol']['throttle_fill_rate'],
)
transport = UDPTransport(
discovery,
server._udp_socket((listen_host, listen_port)),
throttle_policy,
config['protocol'],
dict(),
)
app = App(
config,
blockchain_service,
registry,
secret_registry,
transport,
discovery,
)
app.discovery.register(
app.raiden.address,
listen_host,
listen_port,
)
app.raiden.install_payment_network_filters(app.raiden.default_registry.address)
if scenario:
script = json.load(scenario)
tools = ConsoleTools(
app.raiden,
app.discovery,
app.config['settle_timeout'],
app.config['reveal_timeout'],
)
transfers_by_peer = {}
tokens = script['tokens']
token_address = None
peer = None
our_node = hexlify(app.raiden.address)
log.warning('our address is {}'.format(our_node))
for token in tokens:
# skip tokens that we're not part of
nodes = token['channels']
if our_node not in nodes:
continue
partner_nodes = [
node
for node in nodes
if node != our_node
]
# allow for prefunded tokens
if 'token_address' in token:
token_address = token['token_address']
else:
token_address = tools.create_token(registry_contract_address)
transfers_with_amount = token['transfers_with_amount']
# FIXME: in order to do bidirectional channels, only one side
# (i.e. only token['channels'][0]) should
# open; others should join by calling
# raiden.api.deposit, AFTER the channel came alive!
# NOTE: leaving unidirectional for now because it most
# probably will get to higher throughput
log.warning('Waiting for all nodes to come online')
api = RaidenAPI(app.raiden)
for node in partner_nodes:
api.start_health_check_for(node)
while True:
all_reachable = all(
api.get_node_network_state(node) == NODE_NETWORK_REACHABLE
for node in partner_nodes
)
if all_reachable:
break
gevent.sleep(5)
log.warning('All nodes are online')
if our_node != nodes[-1]:
our_index = nodes.index(our_node)
peer = nodes[our_index + 1]
tools.token_network_register(app.raiden.default_registry.address, token_address)
amount = transfers_with_amount[nodes[-1]]
while True:
try:
app.discovery.get(peer.decode('hex'))
break
except KeyError:
log.warning('Error: peer {} not found in discovery'.format(peer))
time.sleep(random.randrange(30))
while True:
try:
log.warning('Opening channel with {} for {}'.format(peer, token_address))
api.channel_open(app.raiden.default_registry.address, token_address, peer)
break
except KeyError:
log.warning('Error: could not open channel with {}'.format(peer))
time.sleep(random.randrange(30))
while True:
try:
log.warning('Funding channel with {} for {}'.format(peer, token_address))
api.channel_deposit(
app.raiden.default_registry.address,
token_address,
peer,
amount,
)
break
except Exception:
log.warning('Error: could not deposit {} for {}'.format(amount, peer))
time.sleep(random.randrange(30))
if our_index == 0:
last_node = nodes[-1]
transfers_by_peer[last_node] = int(amount)
else:
peer = nodes[-2]
if stage_prefix is not None:
open('{}.stage1'.format(stage_prefix), 'a').close()
log.warning('Done with initialization, waiting to continue...')
event = gevent.event.Event()
gevent.signal(signal.SIGUSR2, event.set)
event.wait()
transfer_results = {'total_time': 0, 'timestamps': []}
def transfer(token_address, amount_per_transfer, total_transfers, peer, is_async):
def transfer_():
log.warning('Making {} transfers to {}'.format(total_transfers, peer))
initial_time = time.time()
times = [0] * total_transfers
for index in range(total_transfers):
RaidenAPI(app.raiden).transfer(
app.raiden.default_registry.address,
token_address.decode('hex'),
amount_per_transfer,
peer,
)
times[index] = time.time()
transfer_results['total_time'] = time.time() - initial_time
transfer_results['timestamps'] = times
log.warning('Making {} transfers took {}'.format(
total_transfers, transfer_results['total_time']))
log.warning('Times: {}'.format(times))
if is_async:
return gevent.spawn(transfer_)
else:
transfer_()
# If sending to multiple targets, do it asynchronously, otherwise
# keep it simple and just send to the single target on my thread.
if len(transfers_by_peer) > 1:
greenlets = []
for peer_, amount in transfers_by_peer.items():
greenlet = transfer(token_address, 1, amount, peer_, True)
if greenlet is not None:
greenlets.append(greenlet)
gevent.joinall(greenlets)
elif len(transfers_by_peer) == 1:
for peer_, amount in transfers_by_peer.items():
transfer(token_address, 1, amount, peer_, False)
log.warning('Waiting for termination')
open('{}.stage2'.format(stage_prefix), 'a').close()
log.warning('Waiting for transfers to finish, will write results...')
event = gevent.event.Event()
gevent.signal(signal.SIGUSR2, event.set)
event.wait()
open('{}.stage3'.format(stage_prefix), 'a').close()
event = gevent.event.Event()
gevent.signal(signal.SIGQUIT, event.set)
gevent.signal(signal.SIGTERM, event.set)
gevent.signal(signal.SIGINT, event.set)
event.wait()
else:
log.warning('No scenario file supplied, doing nothing!')
open('{}.stage2'.format(stage_prefix), 'a').close()
event = gevent.event.Event()
gevent.signal(signal.SIGQUIT, event.set)
gevent.signal(signal.SIGTERM, event.set)
gevent.signal(signal.SIGINT, event.set)
event.wait()
app.stop()
def test_recovery_happy_case(
raiden_network,
number_of_nodes,
deposit,
token_addresses,
network_wait,
skip_if_not_udp, # pylint: disable=unused-argument
):
app0, app1, app2 = raiden_network
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
payment_network_id = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state, payment_network_id, token_address)
# make a few transfers from app0 to app2
amount = 1
spent_amount = deposit - 2
identifier = 0
for identifier in range(spent_amount):
transfer_and_assert_path(
path=raiden_network,
token_address=token_address,
amount=amount,
identifier=identifier,
timeout=network_wait * number_of_nodes,
)
app0.raiden.stop()
host_port = (
app0.raiden.config["transport"]["udp"]["host"],
app0.raiden.config["transport"]["udp"]["port"],
)
socket = server._udp_socket(host_port)
new_transport = UDPTransport(
app0.raiden.address,
app0.discovery,
socket,
app0.raiden.transport.throttle_policy,
app0.raiden.config["transport"]["udp"],
)
raiden_event_handler = RaidenEventHandler()
message_handler = WaitForMessage()
app0_restart = App(
config=app0.config,
chain=app0.raiden.chain,
query_start_block=0,
default_registry=app0.raiden.default_registry,
default_secret_registry=app0.raiden.default_secret_registry,
default_service_registry=app0.raiden.default_service_registry,
transport=new_transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
discovery=app0.raiden.discovery,
)
app0.stop()
del app0 # from here on the app0_restart should be used
app0_restart.start()
assert_synced_channel_state(
token_network_identifier,
app0_restart,
deposit - spent_amount,
[],
app1,
deposit + spent_amount,
[],
)
assert_synced_channel_state(
token_network_identifier,
app1,
deposit - spent_amount,
[],
app2,
deposit + spent_amount,
[],
)
# wait for the nodes' healthcheck to update the network statuses
waiting.wait_for_healthy(app0_restart.raiden, app1.raiden.address,
network_wait)
waiting.wait_for_healthy(app1.raiden, app0_restart.raiden.address,
network_wait)
transfer(
initiator_app=app2,
target_app=app0_restart,
token_address=token_address,
amount=amount,
identifier=create_default_identifier(),
timeout=network_wait * number_of_nodes * 2,
)
transfer(
initiator_app=app0_restart,
target_app=app2,
token_address=token_address,
amount=amount,
identifier=create_default_identifier(),
timeout=network_wait * number_of_nodes * 2,
)
assert_synced_channel_state(
token_network_identifier,
app0_restart,
deposit - spent_amount,
[],
app1,
deposit + spent_amount,
[],
)
assert_synced_channel_state(
token_network_identifier,
app1,
deposit - spent_amount,
[],
app2,
deposit + spent_amount,
[],
)
def test_recovery_blockchain_events(
raiden_network,
token_addresses,
network_wait,
skip_if_not_udp, # pylint: disable=unused-argument
):
""" Close one of the two raiden apps that have a channel between them,
have the counterparty close the channel and then make sure the restarted
app sees the change
"""
app0, app1 = raiden_network
token_address = token_addresses[0]
app0.raiden.stop()
host_port = (
app0.raiden.config["transport"]["udp"]["host"],
app0.raiden.config["transport"]["udp"]["port"],
)
socket = server._udp_socket(host_port)
new_transport = UDPTransport(
app0.raiden.address,
app0.discovery,
socket,
app0.raiden.transport.throttle_policy,
app0.raiden.config["transport"]["udp"],
)
app1_api = RaidenAPI(app1.raiden)
app1_api.channel_close(
registry_address=app0.raiden.default_registry.address,
token_address=token_address,
partner_address=app0.raiden.address,
)
app0.stop()
gevent.sleep(1)
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
app0_restart = App(
config=app0.config,
chain=app0.raiden.chain,
query_start_block=0,
default_registry=app0.raiden.default_registry,
default_secret_registry=app0.raiden.default_secret_registry,
default_service_registry=app0.raiden.default_service_registry,
transport=new_transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
discovery=app0.raiden.discovery,
)
del app0 # from here on the app0_restart should be used
app0_restart.raiden.start()
# wait for the nodes' healthcheck to update the network statuses
waiting.wait_for_healthy(app0_restart.raiden, app1.raiden.address,
network_wait)
waiting.wait_for_healthy(app1.raiden, app0_restart.raiden.address,
network_wait)
restarted_state_changes = app0_restart.raiden.wal.storage.get_statechanges_by_identifier(
0, "latest")
assert search_for_item(restarted_state_changes,
ContractReceiveChannelClosed, {})
def tps_run(
host,
port,
config,
privatekey,
rpc_server,
registry_address,
secret_registry_address,
token_address,
transfer_amount,
parallel):
# pylint: disable=too-many-locals,too-many-arguments
ourprivkey, _ = hostport_to_privkeyaddr(host, port)
rpc_connection = rpc_server.split(':')
rpc_connection = (rpc_connection[0], int(rpc_connection[1]))
with codecs.open(config, encoding='utf8') as handler:
config = yaml.load(handler)
config['host'] = host
config['port'] = port
config['privkey'] = ourprivkey
rpc_connection = rpc_server.split(':')
host, port = (rpc_connection[0], int(rpc_connection[1]))
rpc_client = JSONRPCClient(
host,
port,
privatekey,
)
blockchain_service = BlockChainService(privatekey, rpc_client)
discovery = Discovery()
found_ouraddress = False
for node in config['nodes']:
_, address = hostport_to_privkeyaddr(node['host'], node['port'])
discovery.register(address, node['host'], node['port'])
if host == node['host'] and str(port) == node['port']:
found_ouraddress = True
if not found_ouraddress:
print('We are not registered in the configuration file')
sys.exit(1)
throttle_policy = TokenBucket(
config['protocol']['throttle_capacity'],
config['protocol']['throttle_fill_rate'],
)
transport = UDPTransport(
discovery,
server._udp_socket((host, port)),
throttle_policy,
config['protocol'],
)
app = App(
config=config,
chain=blockchain_service,
query_start_block=0,
default_registry=registry_address,
default_secret_registry=secret_registry_address,
transport=transport,
discovery=discovery,
)
for _ in range(parallel):
gevent.spawn(random_transfer, app, token_address, transfer_amount)
# wait for interrupt
event = gevent.event.Event()
gevent.signal(signal.SIGQUIT, event.set)
gevent.signal(signal.SIGTERM, event.set)
gevent.signal(signal.SIGINT, event.set)
event.wait()
app.stop()
def run(privatekey,
registry_contract_address,
discovery_contract_address,
listen_address,
logging,
logfile,
scenario,
stage_prefix,
results_filename): # pylint: disable=unused-argument
# TODO: only enabled logging on "initiators"
slogging.configure(logging, log_file=logfile)
(listen_host, listen_port) = split_endpoint(listen_address)
config = App.default_config.copy()
config['host'] = listen_host
config['port'] = listen_port
config['privatekey_hex'] = privatekey
blockchain_service = BlockChainService(
decode_hex(privatekey),
decode_hex(registry_contract_address),
host="127.0.0.1",
port="8545",
)
discovery = ContractDiscovery(
blockchain_service,
decode_hex(discovery_contract_address)
)
app = App(config, blockchain_service, discovery)
app.discovery.register(
app.raiden.address,
listen_host,
listen_port,
)
app.raiden.register_registry(app.raiden.chain.default_registry)
if scenario:
script = json.load(scenario)
tools = ConsoleTools(
app.raiden,
app.discovery,
app.config['settle_timeout'],
app.config['reveal_timeout'],
)
transfers_by_peer = {}
tokens = script['assets']
token_address = None
peer = None
our_node = app.raiden.address.encode('hex')
log.warning("our address is {}".format(our_node))
for token in tokens:
# skip tokens/assets that we're not part of
nodes = token['channels']
if not our_node in nodes:
continue
# allow for prefunded tokens
if 'token_address' in token:
token_address = token['token_address']
else:
token_address = tools.create_token()
transfers_with_amount = token['transfers_with_amount']
# FIXME: in order to do bidirectional channels, only one side
# (i.e. only token['channels'][0]) should
# open; others should join by calling
# raiden.api.deposit, AFTER the channel came alive!
# NOTE: leaving unidirectional for now because it most
# probably will get to higher throughput
log.warning("Waiting for all nodes to come online")
while not all(tools.ping(node) for node in nodes if node != our_node):
gevent.sleep(5)
log.warning("All nodes are online")
if our_node != nodes[-1]:
our_index = nodes.index(our_node)
peer = nodes[our_index + 1]
channel_manager = tools.register_asset(token_address)
amount = transfers_with_amount[nodes[-1]]
while True:
try:
app.discovery.get(peer.decode('hex'))
break
except KeyError:
log.warning("Error: peer {} not found in discovery".format(peer))
time.sleep(random.randrange(30))
while True:
try:
log.warning("Opening channel with {} for {}".format(peer, token_address))
app.raiden.api.open(token_address, peer)
break
except KeyError:
log.warning("Error: could not open channel with {}".format(peer))
time.sleep(random.randrange(30))
while True:
try:
log.warning("Funding channel with {} for {}".format(peer, token_address))
channel = app.raiden.api.deposit(token_address, peer, amount)
break
except Exception:
log.warning("Error: could not deposit {} for {}".format(amount, peer))
time.sleep(random.randrange(30))
if our_index == 0:
last_node = nodes[-1]
transfers_by_peer[last_node] = int(amount)
else:
peer = nodes[-2]
if stage_prefix is not None:
open('{}.stage1'.format(stage_prefix), 'a').close()
log.warning("Done with initialization, waiting to continue...")
event = gevent.event.Event()
gevent.signal(signal.SIGUSR2, event.set)
event.wait()
transfer_results = {'total_time': 0, 'timestamps': []}
def transfer(token_address, amount_per_transfer, total_transfers, peer, is_async):
def transfer_():
log.warning("Making {} transfers to {}".format(total_transfers, peer))
initial_time = time.time()
times = [0] * total_transfers
for index in xrange(total_transfers):
app.raiden.api.transfer(
token_address.decode('hex'),
amount_per_transfer,
peer,
)
times[index] = time.time()
transfer_results['total_time'] = time.time() - initial_time
transfer_results['timestamps'] = times
log.warning("Making {} transfers took {}".format(
total_transfers, transfer_results['total_time']))
log.warning("Times: {}".format(times))
if is_async:
return gevent.spawn(transfer_)
else:
transfer_()
# If sending to multiple targets, do it asynchronously, otherwise
# keep it simple and just send to the single target on my thread.
if len(transfers_by_peer) > 1:
greenlets = []
for peer_, amount in transfers_by_peer.items():
greenlet = transfer(token_address, 1, amount, peer_, True)
if greenlet is not None:
greenlets.append(greenlet)
gevent.joinall(greenlets)
elif len(transfers_by_peer) == 1:
for peer_, amount in transfers_by_peer.items():
transfer(token_address, 1, amount, peer_, False)
log.warning("Waiting for termination")
open('{}.stage2'.format(stage_prefix), 'a').close()
log.warning("Waiting for transfers to finish, will write results...")
event = gevent.event.Event()
gevent.signal(signal.SIGUSR2, event.set)
event.wait()
results = tools.channel_stats_for(token_address, peer)
if transfer_results['total_time'] != 0:
results['total_time'] = transfer_results['total_time']
if len(transfer_results['timestamps']) > 0:
results['timestamps'] = transfer_results['timestamps']
results['channel'] = repr(results['channel']) # FIXME
log.warning("Results: {}".format(results))
with open(results_filename, 'w') as fp:
json.dump(results, fp, indent=2)
open('{}.stage3'.format(stage_prefix), 'a').close()
event = gevent.event.Event()
gevent.signal(signal.SIGQUIT, event.set)
gevent.signal(signal.SIGTERM, event.set)
gevent.signal(signal.SIGINT, event.set)
event.wait()
else:
log.warning("No scenario file supplied, doing nothing!")
open('{}.stage2'.format(stage_prefix), 'a').close()
event = gevent.event.Event()
gevent.signal(signal.SIGQUIT, event.set)
gevent.signal(signal.SIGTERM, event.set)
gevent.signal(signal.SIGINT, event.set)
event.wait()
app.stop()
def app(address,
keystore_path,
eth_rpc_endpoint,
registry_contract_address,
discovery_contract_address,
listen_address,
rpccorsdomain, # pylint: disable=unused-argument
mapped_socket,
logging,
logfile,
log_json,
max_unresponsive_time,
send_ping_time,
api_address,
rpc,
console,
password_file,
web_ui,
datadir):
from raiden.app import App
from raiden.network.rpc.client import BlockChainService
# config_file = args.config_file
(listen_host, listen_port) = split_endpoint(listen_address)
(api_host, api_port) = split_endpoint(api_address)
config = App.DEFAULT_CONFIG.copy()
config['host'] = listen_host
config['port'] = listen_port
config['console'] = console
config['rpc'] = rpc
config['web_ui'] = rpc and web_ui
config['api_host'] = api_host
config['api_port'] = api_port
if mapped_socket:
config['socket'] = mapped_socket.socket
config['external_ip'] = mapped_socket.external_ip
config['external_port'] = mapped_socket.external_port
else:
config['socket'] = None
config['external_ip'] = listen_host
config['external_port'] = listen_port
retries = max_unresponsive_time / DEFAULT_NAT_KEEPALIVE_RETRIES
config['protocol']['nat_keepalive_retries'] = retries
config['protocol']['nat_keepalive_timeout'] = send_ping_time
address_hex = address_encoder(address) if address else None
address_hex, privatekey_bin = prompt_account(address_hex, keystore_path, password_file)
privatekey_hex = privatekey_bin.encode('hex')
config['privatekey_hex'] = privatekey_hex
endpoint = eth_rpc_endpoint
# Fallback default port if only an IP address is given
rpc_port = 8545
if eth_rpc_endpoint.startswith("http://"):
endpoint = eth_rpc_endpoint[len("http://"):]
rpc_port = 80
elif eth_rpc_endpoint.startswith("https://"):
endpoint = eth_rpc_endpoint[len("https://"):]
rpc_port = 443
if ':' not in endpoint: # no port was given in url
rpc_host = endpoint
else:
rpc_host, rpc_port = split_endpoint(endpoint)
try:
blockchain_service = BlockChainService(
privatekey_bin,
registry_contract_address,
host=rpc_host,
port=rpc_port,
)
except ValueError as e:
# ValueError exception raised if:
# - The registry contract address doesn't have code, this might happen
# if the connected geth process is not synced or if the wrong address
# is provided (e.g. using the address from a smart contract deployed on
# ropsten with a geth node connected to morden)
print(e.message)
sys.exit(1)
discovery_tx_cost = GAS_PRICE * DISCOVERY_REGISTRATION_GAS
while True:
balance = blockchain_service.client.balance(address_hex)
if discovery_tx_cost <= balance:
break
print(
'Account has insufficient funds for discovery registration.\n'
'Needed: {} ETH\n'
'Available: {} ETH.\n'
'Please deposit additional funds on this account.'
.format(discovery_tx_cost / float(denoms.ether), balance / float(denoms.ether))
)
if not click.confirm('Try again?'):
sys.exit(1)
discovery = ContractDiscovery(
blockchain_service.node_address,
blockchain_service.discovery(discovery_contract_address)
)
if datadir is None:
# default database directory
raiden_directory = os.path.join(os.path.expanduser('~'), '.raiden')
else:
raiden_directory = datadir
if not os.path.exists(raiden_directory):
os.makedirs(raiden_directory)
user_db_dir = os.path.join(raiden_directory, address_hex[:8])
if not os.path.exists(user_db_dir):
os.makedirs(user_db_dir)
database_path = os.path.join(user_db_dir, 'log.db')
config['database_path'] = database_path
return App(config, blockchain_service, discovery)
def run_app(
address,
keystore_path,
gas_price,
eth_rpc_endpoint,
registry_contract_address,
secret_registry_contract_address,
discovery_contract_address,
listen_address,
mapped_socket,
max_unresponsive_time,
api_address,
rpc,
sync_check,
console,
password_file,
web_ui,
datadir,
transport,
matrix_server,
network_id,
extra_config=None,
**kwargs,
):
# pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument
from raiden.app import App
if transport == 'udp' and not mapped_socket:
raise RuntimeError('Missing socket')
address_hex = to_normalized_address(address) if address else None
address_hex, privatekey_bin = prompt_account(address_hex, keystore_path,
password_file)
address = to_canonical_address(address_hex)
(listen_host, listen_port) = split_endpoint(listen_address)
(api_host, api_port) = split_endpoint(api_address)
if datadir is None:
datadir = os.path.join(os.path.expanduser('~'), '.raiden')
config = deepcopy(App.DEFAULT_CONFIG)
if extra_config:
merge_dict(config, extra_config)
config['transport']['udp']['host'] = listen_host
config['transport']['udp']['port'] = listen_port
config['console'] = console
config['rpc'] = rpc
config['web_ui'] = rpc and web_ui
config['api_host'] = api_host
config['api_port'] = api_port
if mapped_socket:
config['socket'] = mapped_socket.socket
config['transport']['udp']['external_ip'] = mapped_socket.external_ip
config['transport']['udp'][
'external_port'] = mapped_socket.external_port
config['transport_type'] = transport
config['transport']['matrix']['server'] = matrix_server
config['transport']['udp'][
'nat_keepalive_retries'] = DEFAULT_NAT_KEEPALIVE_RETRIES
timeout = max_unresponsive_time / DEFAULT_NAT_KEEPALIVE_RETRIES
config['transport']['udp']['nat_keepalive_timeout'] = timeout
privatekey_hex = hexlify(privatekey_bin)
config['privatekey_hex'] = privatekey_hex
parsed_eth_rpc_endpoint = urlparse(eth_rpc_endpoint)
if not parsed_eth_rpc_endpoint.scheme:
eth_rpc_endpoint = f'http://{eth_rpc_endpoint}'
web3 = Web3(HTTPProvider(eth_rpc_endpoint))
try:
node_version = web3.version.node # pylint: disable=no-member
except ConnectTimeout:
raise EthNodeCommunicationError(
"Couldn't connect to the ethereum node")
supported, _ = is_supported_client(node_version)
if not supported:
print(
'You need a Byzantium enabled ethereum node. Parity >= 1.7.6 or Geth >= 1.7.2'
)
sys.exit(1)
rpc_client = JSONRPCClient(
web3,
privatekey_bin,
gasprice=gas_price,
)
blockchain_service = BlockChainService(privatekey_bin, rpc_client)
net_id = blockchain_service.network_id
if net_id != network_id:
if network_id in constants.ID_TO_NETWORKNAME and net_id in constants.ID_TO_NETWORKNAME:
print((
"The chosen ethereum network '{}' differs from the ethereum client '{}'. "
'Please update your settings.').format(
constants.ID_TO_NETWORKNAME[network_id],
constants.ID_TO_NETWORKNAME[net_id]))
else:
print((
"The chosen ethereum network id '{}' differs from the ethereum client '{}'. "
'Please update your settings.').format(network_id, net_id))
sys.exit(1)
config['chain_id'] = network_id
if sync_check:
check_synced(blockchain_service)
database_path = os.path.join(datadir, 'netid_%s' % net_id, address_hex[:8],
'log.db')
config['database_path'] = database_path
print(
'\nYou are connected to the \'{}\' network and the DB path is: {}'.
format(
constants.ID_TO_NETWORKNAME.get(net_id) or net_id,
database_path,
), )
contract_addresses_given = (registry_contract_address is not None and
secret_registry_contract_address is not None
and discovery_contract_address is not None)
contract_addresses_known = net_id in constants.ID_TO_NETWORK_CONFIG
if not contract_addresses_given and not contract_addresses_known:
print((
"There are known contract addresses for network id '{}'. Please provide "
'them in the command line or the configuration file.'
).format(net_id))
sys.exit(1)
contract_addresses = constants.ID_TO_NETWORK_CONFIG.get(net_id, dict())
try:
token_network_registry = blockchain_service.token_network_registry(
registry_contract_address
or contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY], )
except ContractVersionMismatch:
handle_contract_version_mismatch('token network registry',
registry_contract_address)
except AddressWithoutCode:
handle_contract_no_code('token network registry',
registry_contract_address)
except AddressWrongContract:
handle_contract_wrong_address('token network registry',
registry_contract_address)
try:
secret_registry = blockchain_service.secret_registry(
secret_registry_contract_address
or contract_addresses[CONTRACT_SECRET_REGISTRY], )
except ContractVersionMismatch:
handle_contract_version_mismatch('secret registry',
secret_registry_contract_address)
except AddressWithoutCode:
handle_contract_no_code('secret registry',
secret_registry_contract_address)
except AddressWrongContract:
handle_contract_wrong_address('secret registry',
secret_registry_contract_address)
discovery = None
if transport == 'udp':
check_discovery_registration_gas(blockchain_service, address)
try:
dicovery_proxy = blockchain_service.discovery(
discovery_contract_address
or contract_addresses[CONTRACT_ENDPOINT_REGISTRY], )
discovery = ContractDiscovery(
blockchain_service.node_address,
dicovery_proxy,
)
except ContractVersionMismatch:
handle_contract_version_mismatch('discovery',
discovery_contract_address)
except AddressWithoutCode:
handle_contract_no_code('discovery', discovery_contract_address)
except AddressWrongContract:
handle_contract_wrong_address('discovery',
discovery_contract_address)
throttle_policy = TokenBucket(
config['transport']['udp']['throttle_capacity'],
config['transport']['udp']['throttle_fill_rate'],
)
transport = UDPTransport(
discovery,
mapped_socket.socket,
throttle_policy,
config['transport']['udp'],
)
elif transport == 'matrix':
try:
transport = MatrixTransport(config['transport']['matrix'])
except RaidenError as ex:
click.secho(f'FATAL: {ex}', fg='red')
sys.exit(1)
else:
raise RuntimeError(f'Unknown transport type "{transport}" given')
try:
chain_config = constants.ID_TO_NETWORK_CONFIG.get(net_id, {})
start_block = chain_config.get(constants.START_QUERY_BLOCK_KEY, 0)
raiden_app = App(
config=config,
chain=blockchain_service,
query_start_block=start_block,
default_registry=token_network_registry,
default_secret_registry=secret_registry,
transport=transport,
discovery=discovery,
)
except RaidenError as e:
click.secho(f'FATAL: {e}', fg='red')
sys.exit(1)
try:
raiden_app.start()
except filelock.Timeout:
name_or_id = constants.ID_TO_NETWORKNAME.get(network_id, network_id)
print(
f'FATAL: Another Raiden instance already running for account {address_hex} on '
f'network id {name_or_id}', )
sys.exit(1)
return raiden_app
def test_payment_statuses_are_restored( # pylint: disable=unused-argument
raiden_network, token_addresses, network_wait):
""" Test that when the Raiden is restarted, the dictionary of
`targets_to_identifiers_to_statuses` is populated before the transport
is started.
This should happen because if a client gets restarted during a transfer
cycle, once restarted, the client will proceed with the cycle
until the transfer is successfully sent. However, the dictionary
`targets_to_identifiers_to_statuses` will not contain the payment
identifiers that were originally registered when the previous client
started the transfers.
Related issue: https://github.com/raiden-network/raiden/issues/3432
"""
app0, app1 = raiden_network
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
token_network_registry_address = app0.raiden.default_registry.address
token_network_address = views.get_token_network_address_by_token_address(
chain_state, token_network_registry_address, token_address)
# make a few transfers from app0 to app1
amount = 1
spent_amount = TokenAmount(7)
for identifier in range(spent_amount):
# Make sure the transfer is not completed
secret = make_secret(identifier)
app0.raiden.raiden_event_handler.hold(SendSecretReveal,
{"secret": secret})
identifier = identifier + 1
payment_status = app0.raiden.mediated_transfer_async(
token_network_address=token_network_address,
amount=amount,
target=app1.raiden.address,
identifier=identifier,
secret=secret,
)
assert payment_status.payment_identifier == identifier
app0_restart = App(
config=app0.config,
rpc_client=app0.raiden.rpc_client,
proxy_manager=app0.raiden.proxy_manager,
query_start_block=BlockNumber(0),
default_registry=app0.raiden.default_registry,
default_secret_registry=app0.raiden.default_secret_registry,
default_service_registry=app0.raiden.default_service_registry,
default_one_to_n_address=app0.raiden.default_one_to_n_address,
default_msc_address=app0.raiden.default_msc_address,
transport=MatrixTransport(app0.raiden.config["transport"]["matrix"]),
raiden_event_handler=RaidenEventHandler(),
message_handler=MessageHandler(),
routing_mode=RoutingMode.PRIVATE,
)
app0.stop()
del app0 # from here on the app0_restart should be used
# stop app1 to make sure that we don't complete the transfers before our checks
app1.stop()
app0_restart.start()
# Check that the payment statuses were restored properly after restart
for identifier in range(spent_amount):
identifier = PaymentID(identifier + 1)
mapping = app0_restart.raiden.targets_to_identifiers_to_statuses
status = mapping[app1.raiden.address][identifier]
assert status.amount == 1
assert status.payment_identifier == identifier
assert status.token_network_address == token_network_address
app1.start() # now that our checks are done start app1 again
with watch_for_unlock_failures(*raiden_network):
waiting.wait_for_healthy(app0_restart.raiden, app1.raiden.address,
network_wait)
waiting.wait_for_payment_balance(
raiden=app1.raiden,
token_network_registry_address=token_network_registry_address,
token_address=token_address,
partner_address=app0_restart.raiden.address,
target_address=app1.raiden.address,
target_balance=spent_amount,
retry_timeout=network_wait,
)
# Check that payments are completed after both nodes come online after restart
for identifier in range(spent_amount):
assert raiden_events_search_for_item(
app0_restart.raiden,
EventPaymentSentSuccess,
{
"identifier": identifier + 1,
"amount": 1
},
)
def run(
privatekey,
registry_contract_address,
secret_registry_contract_address,
discovery_contract_address,
listen_address,
structlog,
logfile,
scenario,
stage_prefix,
): # pylint: disable=unused-argument
# TODO: only enabled structlog on "initiators"
structlog.configure(structlog, log_file=logfile)
(listen_host, listen_port) = split_endpoint(listen_address)
config = App.DEFAULT_CONFIG.copy()
config['host'] = listen_host
config['port'] = listen_port
config['privatekey_hex'] = privatekey
privatekey_bin = decode_hex(privatekey)
rpc_client = JSONRPCClient(
'127.0.0.1',
8545,
privatekey_bin,
)
blockchain_service = BlockChainService(privatekey_bin, rpc_client)
discovery = ContractDiscovery(
blockchain_service,
decode_hex(discovery_contract_address),
)
registry = blockchain_service.token_network_registry(
registry_contract_address,
)
secret_registry = blockchain_service.secret_registry(
secret_registry_contract_address,
)
throttle_policy = TokenBucket(
config['protocol']['throttle_capacity'],
config['protocol']['throttle_fill_rate'],
)
transport = UDPTransport(
discovery=discovery,
udpsocket=gevent.server._udp_socket((listen_host, listen_port)),
throttle_policy=throttle_policy,
config=config['protocol'],
)
app = App(
config=config,
chain=blockchain_service,
query_start_block=0,
default_registry=registry,
default_secret_registry=secret_registry,
transport=transport,
discovery=discovery,
)
app.discovery.register(
app.raiden.address,
listen_host,
listen_port,
)
from_block = 0
app.raiden.install_all_blockchain_filters(
app.raiden.default_registry,
app.raiden.default_secret_registry,
from_block,
)
if scenario:
script = json.load(scenario)
tools = ConsoleTools(
app.raiden,
app.discovery,
app.config['settle_timeout'],
app.config['reveal_timeout'],
)
transfers_by_peer = {}
tokens = script['tokens']
token_address = None
peer = None
our_node = hexlify(app.raiden.address)
log.warning('our address is {}'.format(our_node))
for token in tokens:
# skip tokens that we're not part of
nodes = token['channels']
if our_node not in nodes:
continue
partner_nodes = [
node
for node in nodes
if node != our_node
]
# allow for prefunded tokens
if 'token_address' in token:
token_address = token['token_address']
else:
token_address = tools.create_token(registry_contract_address)
transfers_with_amount = token['transfers_with_amount']
# FIXME: in order to do bidirectional channels, only one side
# (i.e. only token['channels'][0]) should
# open; others should join by calling
# raiden.api.deposit, AFTER the channel came alive!
# NOTE: leaving unidirectional for now because it most
# probably will get to higher throughput
log.warning('Waiting for all nodes to come online')
api = RaidenAPI(app.raiden)
for node in partner_nodes:
api.start_health_check_for(node)
while True:
all_reachable = all(
api.get_node_network_state(node) == NODE_NETWORK_REACHABLE
for node in partner_nodes
)
if all_reachable:
break
gevent.sleep(5)
log.warning('All nodes are online')
if our_node != nodes[-1]:
our_index = nodes.index(our_node)
peer = nodes[our_index + 1]
tools.token_network_register(app.raiden.default_registry.address, token_address)
amount = transfers_with_amount[nodes[-1]]
while True:
try:
app.discovery.get(peer.decode('hex'))
break
except KeyError:
log.warning('Error: peer {} not found in discovery'.format(peer))
time.sleep(random.randrange(30))
while True:
try:
log.warning('Opening channel with {} for {}'.format(peer, token_address))
api.channel_open(app.raiden.default_registry.address, token_address, peer)
break
except KeyError:
log.warning('Error: could not open channel with {}'.format(peer))
time.sleep(random.randrange(30))
while True:
try:
log.warning('Funding channel with {} for {}'.format(peer, token_address))
api.channel_deposit(
app.raiden.default_registry.address,
token_address,
peer,
amount,
)
break
except Exception:
log.warning('Error: could not deposit {} for {}'.format(amount, peer))
time.sleep(random.randrange(30))
if our_index == 0:
last_node = nodes[-1]
transfers_by_peer[last_node] = int(amount)
if stage_prefix is not None:
open('{}.stage1'.format(stage_prefix), 'a').close()
log.warning('Done with initialization, waiting to continue...')
event = gevent.event.Event()
gevent.signal(signal.SIGUSR2, event.set)
event.wait()
transfer_results = {'total_time': 0, 'timestamps': []}
def transfer(token_address, amount_per_transfer, total_transfers, peer, is_async):
def transfer_():
log.warning('Making {} transfers to {}'.format(total_transfers, peer))
initial_time = time.time()
times = [0] * total_transfers
for index in range(total_transfers):
RaidenAPI(app.raiden).transfer(
app.raiden.default_registry.address,
token_address.decode('hex'),
amount_per_transfer,
peer,
)
times[index] = time.time()
transfer_results['total_time'] = time.time() - initial_time
transfer_results['timestamps'] = times
log.warning('Making {} transfers took {}'.format(
total_transfers, transfer_results['total_time']))
log.warning('Times: {}'.format(times))
if is_async:
return gevent.spawn(transfer_)
else:
transfer_()
# If sending to multiple targets, do it asynchronously, otherwise
# keep it simple and just send to the single target on my thread.
if len(transfers_by_peer) > 1:
greenlets = []
for peer_, amount in transfers_by_peer.items():
greenlet = transfer(token_address, 1, amount, peer_, True)
if greenlet is not None:
greenlets.append(greenlet)
gevent.joinall(greenlets)
elif len(transfers_by_peer) == 1:
for peer_, amount in transfers_by_peer.items():
transfer(token_address, 1, amount, peer_, False)
log.warning('Waiting for termination')
open('{}.stage2'.format(stage_prefix), 'a').close()
log.warning('Waiting for transfers to finish, will write results...')
event = gevent.event.Event()
gevent.signal(signal.SIGUSR2, event.set)
event.wait()
open('{}.stage3'.format(stage_prefix), 'a').close()
event = gevent.event.Event()
gevent.signal(signal.SIGQUIT, event.set)
gevent.signal(signal.SIGTERM, event.set)
gevent.signal(signal.SIGINT, event.set)
event.wait()
else:
log.warning('No scenario file supplied, doing nothing!')
open('{}.stage2'.format(stage_prefix), 'a').close()
event = gevent.event.Event()
gevent.signal(signal.SIGQUIT, event.set)
gevent.signal(signal.SIGTERM, event.set)
gevent.signal(signal.SIGINT, event.set)
event.wait()
app.stop()
def test_send_queued_messages(
raiden_network,
number_of_nodes,
deposit,
token_addresses,
network_wait,
skip_if_not_matrix,
):
"""Test re-sending of undelivered messages on node restart"""
app0, app1 = raiden_network
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
payment_network_id = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state,
payment_network_id,
token_address,
)
with dont_handle_node_change_network_state():
# stop app1 - transfer must be left unconfirmed
app1.stop()
# make a few transfers from app0 to app1
amount = 1
spent_amount = 7
identifier = 1
for _ in range(spent_amount):
app0.raiden.mediated_transfer_async(
token_network_identifier=token_network_identifier,
amount=amount,
target=app1.raiden.address,
identifier=identifier,
)
identifier += 1
# restart app0
app0.raiden.stop()
new_transport = MatrixTransport(
app0.raiden.config['transport']['matrix'],
)
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
app0_restart = App(
config=app0.config,
chain=app0.raiden.chain,
query_start_block=0,
default_registry=app0.raiden.default_registry,
default_secret_registry=app0.raiden.default_secret_registry,
transport=new_transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
discovery=app0.raiden.discovery,
)
app0.stop()
del app0 # from here on the app0_restart should be used
app1.start()
app0_restart.start()
waiting.wait_for_healthy(
app0_restart.raiden,
app1.raiden.address,
network_wait,
)
waiting.wait_for_healthy(
app1.raiden,
app0_restart.raiden.address,
network_wait,
)
exception = RuntimeError('Timeout while waiting for new channel')
with gevent.Timeout(5, exception=exception):
waiting.wait_for_newchannel(
raiden=app0_restart.raiden,
payment_network_id=payment_network_id,
token_address=token_address,
partner_address=app1.raiden.address,
retry_timeout=network_wait,
)
exception = RuntimeError('Timeout while waiting for balance update for app0')
with gevent.Timeout(30, exception=exception):
waiting.wait_for_payment_balance(
raiden=app0_restart.raiden,
payment_network_id=payment_network_id,
token_address=token_address,
partner_address=app1.raiden.address,
target_address=app1.raiden.address,
target_balance=spent_amount,
retry_timeout=network_wait,
)
waiting.wait_for_payment_balance(
raiden=app1.raiden,
payment_network_id=payment_network_id,
token_address=token_address,
partner_address=app0_restart.raiden.address,
target_address=app1.raiden.address,
target_balance=spent_amount,
retry_timeout=network_wait,
)
assert_synced_channel_state(
token_network_identifier,
app0_restart, deposit - spent_amount, [],
app1, deposit + spent_amount, [],
)
def create_apps(
chain_id,
blockchain_services,
endpoint_discovery_services,
token_network_registry_address,
secret_registry_address,
raiden_udp_ports,
reveal_timeout,
settle_timeout,
database_paths,
retry_interval,
retries_before_backoff,
throttle_capacity,
throttle_fill_rate,
nat_invitation_timeout,
nat_keepalive_retries,
nat_keepalive_timeout,
environment_type,
unrecoverable_error_should_crash,
local_matrix_url=None,
private_rooms=None,
):
""" Create the apps."""
# pylint: disable=too-many-locals
services = zip(blockchain_services, endpoint_discovery_services)
apps = []
for idx, (blockchain, discovery) in enumerate(services):
port = raiden_udp_ports[idx]
private_key = blockchain.private_key
address = privatekey_to_address(private_key)
host = '127.0.0.1'
config = {
'chain_id': chain_id,
'environment_type': environment_type,
'unrecoverable_error_should_crash':
unrecoverable_error_should_crash,
'privatekey_hex': encode_hex(private_key),
'reveal_timeout': reveal_timeout,
'settle_timeout': settle_timeout,
'database_path': database_paths[idx],
'blockchain': {
'confirmation_blocks': DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS,
},
'transport': {
'udp': {
'external_ip': host,
'external_port': port,
'host': host,
'nat_invitation_timeout': nat_invitation_timeout,
'nat_keepalive_retries': nat_keepalive_retries,
'nat_keepalive_timeout': nat_keepalive_timeout,
'port': port,
'retries_before_backoff': retries_before_backoff,
'retry_interval': retry_interval,
'throttle_capacity': throttle_capacity,
'throttle_fill_rate': throttle_fill_rate,
},
},
'rpc': True,
'console': False,
}
use_matrix = local_matrix_url is not None
if use_matrix:
merge_dict(
config,
{
'transport_type': 'matrix',
'transport': {
'matrix': {
'discovery_room': 'discovery',
'retries_before_backoff': retries_before_backoff,
'retry_interval': retry_interval,
'server': local_matrix_url,
'server_name': local_matrix_url.netloc,
'available_servers': [],
'private_rooms': private_rooms,
},
},
},
)
config_copy = App.DEFAULT_CONFIG.copy()
config_copy.update(config)
registry = blockchain.token_network_registry(
token_network_registry_address)
secret_registry = blockchain.secret_registry(secret_registry_address)
if use_matrix:
transport = MatrixTransport(config['transport']['matrix'])
else:
throttle_policy = TokenBucket(
config['transport']['udp']['throttle_capacity'],
config['transport']['udp']['throttle_fill_rate'],
)
transport = UDPTransport(
address,
discovery,
server._udp_socket((host, port)), # pylint: disable=protected-access
throttle_policy,
config['transport']['udp'],
)
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
app = App(
config=config_copy,
chain=blockchain,
query_start_block=0,
default_registry=registry,
default_secret_registry=secret_registry,
transport=transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
discovery=discovery,
)
apps.append(app)
return apps
def test_recovery_blockchain_events(
raiden_network,
number_of_nodes,
deposit,
token_addresses,
network_wait,
skip_if_not_udp,
):
""" Close one of the two raiden apps that have a channel between them,
have the counterparty close the channel and then make sure the restarted
app sees the change
"""
app0, app1 = raiden_network
token_address = token_addresses[0]
app0.raiden.stop()
host_port = (app0.raiden.config['host'], app0.raiden.config['port'])
socket = server._udp_socket(host_port)
new_transport = UDPTransport(
app0.discovery,
socket,
app0.raiden.transport.throttle_policy,
app0.raiden.config['transport'],
)
app1_api = RaidenAPI(app1.raiden)
app1_api.channel_close(
registry_address=app0.raiden.default_registry.address,
token_address=token_address,
partner_address=app0.raiden.address,
)
app0.stop()
import gevent
gevent.sleep(1)
app0_restart = App(
config=app0.config,
chain=app0.raiden.chain,
query_start_block=0,
default_registry=app0.raiden.default_registry,
default_secret_registry=app0.raiden.default_secret_registry,
transport=new_transport,
discovery=app0.raiden.discovery,
)
del app0 # from here on the app0_restart should be used
# wait for the nodes' healthcheck to update the network statuses
waiting.wait_for_healthy(
app0_restart.raiden,
app1.raiden.address,
network_wait,
)
waiting.wait_for_healthy(
app1.raiden,
app0_restart.raiden.address,
network_wait,
)
restarted_state_changes = app0_restart.raiden.wal.storage.get_statechanges_by_identifier(
0,
'latest',
)
assert must_contain_entry(restarted_state_changes,
ContractReceiveChannelClosed, {})
def run_app(
address,
keystore_path,
gas_price,
eth_rpc_endpoint,
registry_contract_address,
secret_registry_contract_address,
discovery_contract_address,
listen_address,
mapped_socket,
max_unresponsive_time,
api_address,
rpc,
sync_check,
console,
password_file,
web_ui,
datadir,
transport,
matrix_server,
network_id,
network_type,
config=None,
extra_config=None,
**kwargs,
):
# pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument
from raiden.app import App
_assert_sql_version()
if transport == 'udp' and not mapped_socket:
raise RuntimeError('Missing socket')
if datadir is None:
datadir = os.path.join(os.path.expanduser('~'), '.raiden')
address_hex = to_normalized_address(address) if address else None
address_hex, privatekey_bin = prompt_account(address_hex, keystore_path, password_file)
address = to_canonical_address(address_hex)
(listen_host, listen_port) = split_endpoint(listen_address)
(api_host, api_port) = split_endpoint(api_address)
config['transport']['udp']['host'] = listen_host
config['transport']['udp']['port'] = listen_port
config['console'] = console
config['rpc'] = rpc
config['web_ui'] = rpc and web_ui
config['api_host'] = api_host
config['api_port'] = api_port
if mapped_socket:
config['socket'] = mapped_socket.socket
config['transport']['udp']['external_ip'] = mapped_socket.external_ip
config['transport']['udp']['external_port'] = mapped_socket.external_port
config['transport_type'] = transport
config['transport']['matrix']['server'] = matrix_server
config['transport']['udp']['nat_keepalive_retries'] = DEFAULT_NAT_KEEPALIVE_RETRIES
timeout = max_unresponsive_time / DEFAULT_NAT_KEEPALIVE_RETRIES
config['transport']['udp']['nat_keepalive_timeout'] = timeout
privatekey_hex = hexlify(privatekey_bin)
config['privatekey_hex'] = privatekey_hex
parsed_eth_rpc_endpoint = urlparse(eth_rpc_endpoint)
if not parsed_eth_rpc_endpoint.scheme:
eth_rpc_endpoint = f'http://{eth_rpc_endpoint}'
web3 = _setup_web3(eth_rpc_endpoint)
rpc_client = JSONRPCClient(
web3,
privatekey_bin,
gas_price_strategy=gas_price,
)
blockchain_service = BlockChainService(privatekey_bin, rpc_client)
given_numeric_network_id = network_id.value if isinstance(network_id, ChainId) else network_id
node_numeric_network_id = blockchain_service.network_id
known_given_network_id = networkid_is_known(given_numeric_network_id)
known_node_network_id = networkid_is_known(node_numeric_network_id)
if known_given_network_id:
given_network_id = ChainId(given_numeric_network_id)
if known_node_network_id:
node_network_id = ChainId(node_numeric_network_id)
if node_numeric_network_id != given_numeric_network_id:
if known_given_network_id and known_node_network_id:
click.secho(
f"The chosen ethereum network '{given_network_id.name.lower()}' "
f"differs from the ethereum client '{node_network_id.name.lower()}'. "
"Please update your settings.",
fg='red',
)
else:
click.secho(
f"The chosen ethereum network id '{given_numeric_network_id}' differs "
f"from the ethereum client '{node_numeric_network_id}'. "
"Please update your settings.",
fg='red',
)
sys.exit(1)
config['chain_id'] = given_numeric_network_id
log.debug('Network type', type=network_type)
if network_type == 'main':
config['network_type'] = NetworkType.MAIN
# Forcing private rooms to true for the mainnet
config['transport']['matrix']['private_rooms'] = True
else:
config['network_type'] = NetworkType.TEST
network_type = config['network_type']
chain_config = {}
contract_addresses_known = False
contract_addresses = dict()
if node_network_id in ID_TO_NETWORK_CONFIG:
network_config = ID_TO_NETWORK_CONFIG[node_network_id]
not_allowed = (
NetworkType.TEST not in network_config and
network_type == NetworkType.TEST
)
if not_allowed:
click.secho(
'The chosen network {} has no test configuration but a test network type '
'was given. This is not allowed.'.format(
ID_TO_NETWORKNAME[node_network_id],
),
fg='red',
)
sys.exit(1)
if network_type in network_config:
chain_config = network_config[network_type]
contract_addresses = chain_config['contract_addresses']
contract_addresses_known = True
if sync_check:
check_synced(blockchain_service, known_node_network_id)
contract_addresses_given = (
registry_contract_address is not None and
secret_registry_contract_address is not None and
discovery_contract_address is not None
)
if not contract_addresses_given and not contract_addresses_known:
click.secho(
f"There are no known contract addresses for network id '{given_numeric_network_id}'. "
"Please provide them on the command line or in the configuration file.",
fg='red',
)
sys.exit(1)
try:
token_network_registry = blockchain_service.token_network_registry(
registry_contract_address or contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY],
)
except ContractVersionMismatch:
handle_contract_version_mismatch('token network registry', registry_contract_address)
except AddressWithoutCode:
handle_contract_no_code('token network registry', registry_contract_address)
except AddressWrongContract:
handle_contract_wrong_address('token network registry', registry_contract_address)
try:
secret_registry = blockchain_service.secret_registry(
secret_registry_contract_address or contract_addresses[CONTRACT_SECRET_REGISTRY],
)
except ContractVersionMismatch:
handle_contract_version_mismatch('secret registry', secret_registry_contract_address)
except AddressWithoutCode:
handle_contract_no_code('secret registry', secret_registry_contract_address)
except AddressWrongContract:
handle_contract_wrong_address('secret registry', secret_registry_contract_address)
database_path = os.path.join(
datadir,
f'node_{pex(address)}',
f'netid_{given_numeric_network_id}',
f'network_{pex(token_network_registry.address)}',
f'v{RAIDEN_DB_VERSION}_log.db',
)
config['database_path'] = database_path
print(
'\nYou are connected to the \'{}\' network and the DB path is: {}'.format(
ID_TO_NETWORKNAME.get(given_network_id, given_numeric_network_id),
database_path,
),
)
discovery = None
if transport == 'udp':
transport, discovery = _setup_udp(
config,
blockchain_service,
address,
contract_addresses,
discovery_contract_address,
)
elif transport == 'matrix':
transport = _setup_matrix(config)
else:
raise RuntimeError(f'Unknown transport type "{transport}" given')
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
try:
start_block = chain_config.get(START_QUERY_BLOCK_KEY, 0)
raiden_app = App(
config=config,
chain=blockchain_service,
query_start_block=start_block,
default_registry=token_network_registry,
default_secret_registry=secret_registry,
transport=transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
discovery=discovery,
)
except RaidenError as e:
click.secho(f'FATAL: {e}', fg='red')
sys.exit(1)
try:
raiden_app.start()
except RuntimeError as e:
click.secho(f'FATAL: {e}', fg='red')
sys.exit(1)
except filelock.Timeout:
name_or_id = ID_TO_NETWORKNAME.get(given_network_id, given_numeric_network_id)
click.secho(
f'FATAL: Another Raiden instance already running for account {address_hex} on '
f'network id {name_or_id}',
fg='red',
)
sys.exit(1)
return raiden_app
def app(address, keystore_path, gas_price, eth_rpc_endpoint,
registry_contract_address, discovery_contract_address, listen_address,
rpccorsdomain, mapped_socket, logging, logfile, log_json,
max_unresponsive_time, send_ping_time, api_address, rpc, sync_check,
console, password_file, web_ui, datadir, eth_client_communication,
nat):
# pylint: disable=too-many-locals,too-many-branches,too-many-statements,unused-argument
from raiden.app import App
from raiden.network.blockchain_service import BlockChainService
(listen_host, listen_port) = split_endpoint(listen_address)
(api_host, api_port) = split_endpoint(api_address)
config = App.DEFAULT_CONFIG.copy()
config['host'] = listen_host
config['port'] = listen_port
config['console'] = console
config['rpc'] = rpc
config['web_ui'] = rpc and web_ui
config['api_host'] = api_host
config['api_port'] = api_port
if mapped_socket:
config['socket'] = mapped_socket.socket
config['external_ip'] = mapped_socket.external_ip
config['external_port'] = mapped_socket.external_port
else:
config['socket'] = None
config['external_ip'] = listen_host
config['external_port'] = listen_port
config['protocol']['nat_keepalive_retries'] = DEFAULT_NAT_KEEPALIVE_RETRIES
timeout = max_unresponsive_time / DEFAULT_NAT_KEEPALIVE_RETRIES
config['protocol']['nat_keepalive_timeout'] = timeout
address_hex = address_encoder(address) if address else None
address_hex, privatekey_bin = prompt_account(address_hex, keystore_path,
password_file)
address = address_decoder(address_hex)
privatekey_hex = hexlify(privatekey_bin)
config['privatekey_hex'] = privatekey_hex
endpoint = eth_rpc_endpoint
# Fallback to default port if only an IP address is given
rpc_port = 8545
if eth_rpc_endpoint.startswith('http://'):
endpoint = eth_rpc_endpoint[len('http://'):]
rpc_port = 80
elif eth_rpc_endpoint.startswith('https://'):
endpoint = eth_rpc_endpoint[len('https://'):]
rpc_port = 443
if ':' not in endpoint: # no port was given in url
rpc_host = endpoint
else:
rpc_host, rpc_port = split_endpoint(endpoint)
rpc_client = JSONRPCClient(
rpc_host,
rpc_port,
privatekey_bin,
gas_price,
)
# this assumes the eth node is already online
if not check_json_rpc(rpc_client):
sys.exit(1)
blockchain_service = BlockChainService(
privatekey_bin,
rpc_client,
gas_price,
)
if sync_check:
check_synced(blockchain_service)
discovery_tx_cost = rpc_client.gasprice() * DISCOVERY_TX_GAS_LIMIT
while True:
balance = blockchain_service.client.balance(address)
if discovery_tx_cost <= balance:
break
print('Account has insufficient funds for discovery registration.\n'
'Needed: {} ETH\n'
'Available: {} ETH.\n'
'Please deposit additional funds into this account.'.format(
discovery_tx_cost / denoms.ether, balance / denoms.ether))
if not click.confirm('Try again?'):
sys.exit(1)
registry = blockchain_service.registry(registry_contract_address, )
discovery = ContractDiscovery(
blockchain_service.node_address,
blockchain_service.discovery(discovery_contract_address))
if datadir is None:
# default database directory
raiden_directory = os.path.join(os.path.expanduser('~'), '.raiden')
else:
raiden_directory = datadir
if not os.path.exists(raiden_directory):
os.makedirs(raiden_directory)
user_db_dir = os.path.join(raiden_directory, address_hex[:8])
if not os.path.exists(user_db_dir):
os.makedirs(user_db_dir)
database_path = os.path.join(user_db_dir, 'log.db')
config['database_path'] = database_path
return App(
config,
blockchain_service,
registry,
discovery,
)
def app(address, keystore_path, eth_rpc_endpoint, registry_contract_address,
discovery_contract_address, listen_address, logging, logfile,
max_unresponsive_time, send_ping_time):
slogging.configure(logging, log_file=logfile)
# config_file = args.config_file
(listen_host, listen_port) = split_endpoint(listen_address)
config = App.default_config.copy()
config['host'] = listen_host
config['port'] = listen_port
config['max_unresponsive_time'] = max_unresponsive_time
config['send_ping_time'] = send_ping_time
accmgr = AccountManager(keystore_path)
if not accmgr.accounts:
raise RuntimeError('No Ethereum accounts found in the user\'s system')
if not accmgr.address_in_keystore(address):
addresses = list(accmgr.accounts.keys())
formatted_addresses = [
'[{:3d}] - 0x{}'.format(idx, addr)
for idx, addr in enumerate(addresses)
]
should_prompt = True
while should_prompt:
idx = click.prompt(
"The following accounts were found in your machine:\n\n{}"
"\nSelect one of them by index to continue: ".format(
"\n".join(formatted_addresses)),
type=int)
if idx >= 0 and idx < len(addresses):
should_prompt = False
else:
print("\nError: Provided index '{}' is out of bounds\n".format(
idx))
address = addresses[idx]
privatekey = accmgr.get_privkey(address)
config['privatekey_hex'] = encode_hex(privatekey)
endpoint = eth_rpc_endpoint
if eth_rpc_endpoint.startswith("http://"):
endpoint = eth_rpc_endpoint[len("http://"):]
rpc_port = 80
elif eth_rpc_endpoint.startswith("https://"):
endpoint = eth_rpc_endpoint[len("https://"):]
rpc_port = 443
if ':' not in endpoint: # no port was given in url
rpc_host = endpoint
else:
rpc_host, rpc_port = split_endpoint(endpoint)
blockchain_service = BlockChainService(
privatekey,
decode_hex(registry_contract_address),
host=rpc_host,
port=rpc_port,
)
discovery = ContractDiscovery(
blockchain_service.node_address,
blockchain_service.discovery(discovery_contract_address))
return App(config, blockchain_service, discovery)
def run(privatekey, registry_contract_address, discovery_contract_address,
listen_address, logging, logfile, scenario, stage_prefix,
results_filename): # pylint: disable=unused-argument
# TODO: only enabled logging on "initiators"
slogging.configure(logging, log_file=logfile)
(listen_host, listen_port) = split_endpoint(listen_address)
config = App.default_config.copy()
config['host'] = listen_host
config['port'] = listen_port
config['privatekey_hex'] = privatekey
blockchain_service = BlockChainService(
decode_hex(privatekey),
decode_hex(registry_contract_address),
host="127.0.0.1",
port="8545",
)
discovery = ContractDiscovery(blockchain_service,
decode_hex(discovery_contract_address))
app = App(config, blockchain_service, discovery)
app.discovery.register(
app.raiden.address,
listen_host,
listen_port,
)
app.raiden.register_registry(app.raiden.chain.default_registry)
if scenario:
script = json.load(scenario)
tools = ConsoleTools(
app.raiden,
app.discovery,
app.config['settle_timeout'],
app.config['reveal_timeout'],
)
transfers_by_peer = {}
tokens = script['tokens']
token_address = None
peer = None
our_node = app.raiden.address.encode('hex')
log.warning("our address is {}".format(our_node))
for token in tokens:
# skip tokens that we're not part of
nodes = token['channels']
if not our_node in nodes:
continue
# allow for prefunded tokens
if 'token_address' in token:
token_address = token['token_address']
else:
token_address = tools.create_token()
transfers_with_amount = token['transfers_with_amount']
# FIXME: in order to do bidirectional channels, only one side
# (i.e. only token['channels'][0]) should
# open; others should join by calling
# raiden.api.deposit, AFTER the channel came alive!
# NOTE: leaving unidirectional for now because it most
# probably will get to higher throughput
log.warning("Waiting for all nodes to come online")
while not all(
tools.ping(node) for node in nodes if node != our_node):
gevent.sleep(5)
log.warning("All nodes are online")
if our_node != nodes[-1]:
our_index = nodes.index(our_node)
peer = nodes[our_index + 1]
channel_manager = tools.register_token(token_address)
amount = transfers_with_amount[nodes[-1]]
while True:
try:
app.discovery.get(peer.decode('hex'))
break
except KeyError:
log.warning(
"Error: peer {} not found in discovery".format(
peer))
time.sleep(random.randrange(30))
while True:
try:
log.warning("Opening channel with {} for {}".format(
peer, token_address))
app.raiden.api.open(token_address, peer)
break
except KeyError:
log.warning(
"Error: could not open channel with {}".format(
peer))
time.sleep(random.randrange(30))
while True:
try:
log.warning("Funding channel with {} for {}".format(
peer, token_address))
channel = app.raiden.api.deposit(
token_address, peer, amount)
break
except Exception:
log.warning(
"Error: could not deposit {} for {}".format(
amount, peer))
time.sleep(random.randrange(30))
if our_index == 0:
last_node = nodes[-1]
transfers_by_peer[last_node] = int(amount)
else:
peer = nodes[-2]
if stage_prefix is not None:
open('{}.stage1'.format(stage_prefix), 'a').close()
log.warning("Done with initialization, waiting to continue...")
event = gevent.event.Event()
gevent.signal(signal.SIGUSR2, event.set)
event.wait()
transfer_results = {'total_time': 0, 'timestamps': []}
def transfer(token_address, amount_per_transfer, total_transfers, peer,
is_async):
def transfer_():
log.warning("Making {} transfers to {}".format(
total_transfers, peer))
initial_time = time.time()
times = [0] * total_transfers
for index in xrange(total_transfers):
app.raiden.api.transfer(
token_address.decode('hex'),
amount_per_transfer,
peer,
)
times[index] = time.time()
transfer_results['total_time'] = time.time() - initial_time
transfer_results['timestamps'] = times
log.warning("Making {} transfers took {}".format(
total_transfers, transfer_results['total_time']))
log.warning("Times: {}".format(times))
if is_async:
return gevent.spawn(transfer_)
else:
transfer_()
# If sending to multiple targets, do it asynchronously, otherwise
# keep it simple and just send to the single target on my thread.
if len(transfers_by_peer) > 1:
greenlets = []
for peer_, amount in transfers_by_peer.items():
greenlet = transfer(token_address, 1, amount, peer_, True)
if greenlet is not None:
greenlets.append(greenlet)
gevent.joinall(greenlets)
elif len(transfers_by_peer) == 1:
for peer_, amount in transfers_by_peer.items():
transfer(token_address, 1, amount, peer_, False)
log.warning("Waiting for termination")
open('{}.stage2'.format(stage_prefix), 'a').close()
log.warning("Waiting for transfers to finish, will write results...")
event = gevent.event.Event()
gevent.signal(signal.SIGUSR2, event.set)
event.wait()
results = tools.channel_stats_for(token_address, peer)
if transfer_results['total_time'] != 0:
results['total_time'] = transfer_results['total_time']
if len(transfer_results['timestamps']) > 0:
results['timestamps'] = transfer_results['timestamps']
results['channel'] = repr(results['channel']) # FIXME
log.warning("Results: {}".format(results))
with open(results_filename, 'w') as fp:
json.dump(results, fp, indent=2)
open('{}.stage3'.format(stage_prefix), 'a').close()
event = gevent.event.Event()
gevent.signal(signal.SIGQUIT, event.set)
gevent.signal(signal.SIGTERM, event.set)
gevent.signal(signal.SIGINT, event.set)
event.wait()
else:
log.warning("No scenario file supplied, doing nothing!")
open('{}.stage2'.format(stage_prefix), 'a').close()
event = gevent.event.Event()
gevent.signal(signal.SIGQUIT, event.set)
gevent.signal(signal.SIGTERM, event.set)
gevent.signal(signal.SIGINT, event.set)
event.wait()
app.stop()
def test_recovery_unhappy_case(
raiden_network,
number_of_nodes,
deposit,
token_addresses,
network_wait,
skip_if_not_udp,
retry_timeout,
):
app0, app1, app2 = raiden_network
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
payment_network_id = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state,
payment_network_id,
token_address,
)
# make a few transfers from app0 to app2
amount = 1
spent_amount = deposit - 2
for _ in range(spent_amount):
mediated_transfer(
app0,
app2,
token_network_identifier,
amount,
timeout=network_wait * number_of_nodes,
)
app0.raiden.stop()
host_port = (
app0.raiden.config['transport']['udp']['host'],
app0.raiden.config['transport']['udp']['port'],
)
socket = server._udp_socket(host_port)
new_transport = UDPTransport(
app0.raiden.address,
app0.discovery,
socket,
app0.raiden.transport.throttle_policy,
app0.raiden.config['transport']['udp'],
)
app0.stop()
RaidenAPI(app1.raiden).channel_close(
app1.raiden.default_registry.address,
token_address,
app0.raiden.address,
)
channel01 = views.get_channelstate_for(
views.state_from_app(app1),
app1.raiden.default_registry.address,
token_address,
app0.raiden.address,
)
waiting.wait_for_settle(
app1.raiden,
app1.raiden.default_registry.address,
token_address,
[channel01.identifier],
retry_timeout,
)
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
app0_restart = App(
config=app0.config,
chain=app0.raiden.chain,
query_start_block=0,
default_registry=app0.raiden.default_registry,
default_secret_registry=app0.raiden.default_secret_registry,
transport=new_transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
discovery=app0.raiden.discovery,
)
del app0 # from here on the app0_restart should be used
app0_restart.start()
state_changes = app0_restart.raiden.wal.storage.get_statechanges_by_identifier(
from_identifier=0,
to_identifier='latest',
)
assert must_contain_entry(state_changes, ContractReceiveChannelSettled, {
'token_network_identifier': token_network_identifier,
'channel_identifier': channel01.identifier,
})
def run_test_send_queued_messages(
raiden_network,
deposit,
token_addresses,
network_wait,
):
app0, app1 = raiden_network
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
payment_network_id = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state,
payment_network_id,
token_address,
)
with dont_handle_node_change_network_state():
# stop app1 - transfer must be left unconfirmed
app1.stop()
# make a few transfers from app0 to app1
amount = 1
spent_amount = 7
identifier = 1
for _ in range(spent_amount):
app0.raiden.mediated_transfer_async(
token_network_identifier=token_network_identifier,
amount=amount,
target=app1.raiden.address,
identifier=identifier,
)
identifier += 1
# restart app0
app0.raiden.stop()
new_transport = MatrixTransport(
app0.raiden.config['transport']['matrix'], )
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
app0_restart = App(
config=app0.config,
chain=app0.raiden.chain,
query_start_block=0,
default_registry=app0.raiden.default_registry,
default_secret_registry=app0.raiden.default_secret_registry,
default_service_registry=app0.raiden.default_service_registry,
transport=new_transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
discovery=app0.raiden.discovery,
)
app0.stop()
del app0 # from here on the app0_restart should be used
app1.start()
app0_restart.start()
waiting.wait_for_healthy(
app0_restart.raiden,
app1.raiden.address,
network_wait,
)
waiting.wait_for_healthy(
app1.raiden,
app0_restart.raiden.address,
network_wait,
)
exception = RuntimeError('Timeout while waiting for new channel')
with gevent.Timeout(5, exception=exception):
waiting.wait_for_newchannel(
raiden=app0_restart.raiden,
payment_network_id=payment_network_id,
token_address=token_address,
partner_address=app1.raiden.address,
retry_timeout=network_wait,
)
exception = RuntimeError(
'Timeout while waiting for balance update for app0')
with gevent.Timeout(30, exception=exception):
waiting.wait_for_payment_balance(
raiden=app0_restart.raiden,
payment_network_id=payment_network_id,
token_address=token_address,
partner_address=app1.raiden.address,
target_address=app1.raiden.address,
target_balance=spent_amount,
retry_timeout=network_wait,
)
waiting.wait_for_payment_balance(
raiden=app1.raiden,
payment_network_id=payment_network_id,
token_address=token_address,
partner_address=app0_restart.raiden.address,
target_address=app1.raiden.address,
target_balance=spent_amount,
retry_timeout=network_wait,
)
assert_synced_channel_state(
token_network_identifier,
app0_restart,
deposit - spent_amount,
[],
app1,
deposit + spent_amount,
[],
)
def test_recovery_happy_case(
raiden_network,
number_of_nodes,
deposit,
token_addresses,
network_wait,
skip_if_not_udp,
):
app0, app1, app2 = raiden_network
token_address = token_addresses[0]
app2_wait_for = WaitForMessage()
app2.raiden.message_handler = app2_wait_for
chain_state = views.state_from_app(app0)
payment_network_id = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state,
payment_network_id,
token_address,
)
# make a few transfers from app0 to app2
amount = 1
spent_amount = deposit - 2
for _ in range(spent_amount):
mediated_transfer(
app0,
app2,
token_network_identifier,
amount,
timeout=network_wait * number_of_nodes,
)
app0.raiden.stop()
host_port = (
app0.raiden.config['transport']['udp']['host'],
app0.raiden.config['transport']['udp']['port'],
)
socket = server._udp_socket(host_port)
new_transport = UDPTransport(
app0.raiden.address,
app0.discovery,
socket,
app0.raiden.transport.throttle_policy,
app0.raiden.config['transport']['udp'],
)
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
app0_restart = App(
config=app0.config,
chain=app0.raiden.chain,
query_start_block=0,
default_registry=app0.raiden.default_registry,
default_secret_registry=app0.raiden.default_secret_registry,
transport=new_transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
discovery=app0.raiden.discovery,
)
app0.stop()
del app0 # from here on the app0_restart should be used
app0_restart.start()
assert_synced_channel_state(
token_network_identifier,
app0_restart, deposit - spent_amount, [],
app1, deposit + spent_amount, [],
)
assert_synced_channel_state(
token_network_identifier,
app1, deposit - spent_amount, [],
app2, deposit + spent_amount, [],
)
# wait for the nodes' healthcheck to update the network statuses
waiting.wait_for_healthy(
app0_restart.raiden,
app1.raiden.address,
network_wait,
)
waiting.wait_for_healthy(
app1.raiden,
app0_restart.raiden.address,
network_wait,
)
identifier = create_default_identifier()
wait_for_payment = app2_wait_for.wait_for_message(Secret, {'payment_identifier': identifier})
mediated_transfer(
app2,
app0_restart,
token_network_identifier,
amount,
timeout=network_wait * number_of_nodes * 2,
)
mediated_transfer(
initiator_app=app0_restart,
target_app=app2,
token_network_identifier=token_network_identifier,
amount=amount,
identifier=identifier,
timeout=network_wait * number_of_nodes * 2,
)
assert_synced_channel_state(
token_network_identifier,
app0_restart, deposit - spent_amount, [],
app1, deposit + spent_amount, [],
)
wait_for_payment.wait()
assert_synced_channel_state(
token_network_identifier,
app1, deposit - spent_amount, [],
app2, deposit + spent_amount, [],
)