def raiden_network(
token_addresses,
token_network_registry_address,
channels_per_node,
deposit,
settle_timeout,
chain_id,
blockchain_services,
endpoint_discovery_services,
raiden_udp_ports,
reveal_timeout,
database_paths,
retry_interval,
retries_before_backoff,
throttle_capacity,
throttle_fill_rate,
nat_invitation_timeout,
nat_keepalive_retries,
nat_keepalive_timeout,
network_type,
local_matrix_server,
private_rooms,
):
raiden_apps = create_apps(
chain_id=chain_id,
blockchain_services=blockchain_services.blockchain_services,
endpoint_discovery_services=endpoint_discovery_services,
token_network_registry_address=token_network_registry_address,
secret_registry_address=blockchain_services.secret_registry.address,
raiden_udp_ports=raiden_udp_ports,
reveal_timeout=reveal_timeout,
settle_timeout=settle_timeout,
database_paths=database_paths,
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,
network_type=network_type,
local_matrix_url=local_matrix_server,
private_rooms=private_rooms,
)
start_tasks = [gevent.spawn(app.raiden.start) for app in raiden_apps]
gevent.joinall(start_tasks, raise_error=True)
app_channels = create_network_channels(
raiden_apps,
channels_per_node,
)
greenlets = []
for token_address in token_addresses:
for app_pair in app_channels:
greenlets.append(gevent.spawn(
payment_channel_open_and_deposit,
app_pair[0],
app_pair[1],
token_address,
deposit,
settle_timeout,
))
gevent.joinall(greenlets, raise_error=True)
exception = RuntimeError('`raiden_network` fixture setup failed, nodes are unreachable')
with gevent.Timeout(seconds=30, exception=exception):
wait_for_channels(
app_channels,
blockchain_services.deploy_registry.address,
token_addresses,
deposit,
)
# Force blocknumber update
exception = RuntimeError('Alarm failed to start and set up start_block correctly')
with gevent.Timeout(seconds=5, exception=exception):
wait_for_alarm_start(raiden_apps)
yield raiden_apps
shutdown_apps_and_cleanup_tasks(raiden_apps)
def raiden_chain(
token_addresses,
token_network_registry_address,
channels_per_node,
deposit,
settle_timeout,
chain_id,
blockchain_services,
endpoint_discovery_services,
raiden_udp_ports,
reveal_timeout,
database_paths,
retry_interval,
retries_before_backoff,
throttle_capacity,
throttle_fill_rate,
nat_invitation_timeout,
nat_keepalive_retries,
nat_keepalive_timeout,
network_type,
local_matrix_server,
private_rooms,
):
if len(token_addresses) != 1:
raise ValueError('raiden_chain only works with a single token')
assert channels_per_node in (0, 1, 2, CHAIN), (
'deployed_network uses create_sequential_network that can only work '
'with 0, 1 or 2 channels'
)
raiden_apps = create_apps(
chain_id=chain_id,
blockchain_services=blockchain_services.blockchain_services,
endpoint_discovery_services=endpoint_discovery_services,
token_network_registry_address=token_network_registry_address,
secret_registry_address=blockchain_services.secret_registry.address,
raiden_udp_ports=raiden_udp_ports,
reveal_timeout=reveal_timeout,
settle_timeout=settle_timeout,
database_paths=database_paths,
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,
network_type=network_type,
local_matrix_url=local_matrix_server,
private_rooms=private_rooms,
)
start_tasks = [gevent.spawn(app.raiden.start) for app in raiden_apps]
gevent.joinall(start_tasks, raise_error=True)
from_block = 0
for app in raiden_apps:
app.raiden.install_all_blockchain_filters(
app.raiden.default_registry,
app.raiden.default_secret_registry,
from_block,
)
app_channels = create_sequential_channels(
raiden_apps,
channels_per_node,
)
channel_greenlets = []
for token_address in token_addresses:
for app_pair in app_channels:
channel_greenlets.append(gevent.spawn(
payment_channel_open_and_deposit,
app_pair[0],
app_pair[1],
token_address,
deposit,
settle_timeout,
))
gevent.joinall(channel_greenlets, raise_error=True)
exception = RuntimeError('`raiden_chain` fixture setup failed, nodes are unreachable')
with gevent.Timeout(seconds=30, exception=exception):
wait_for_channels(
app_channels,
blockchain_services.deploy_registry.address,
token_addresses,
deposit,
)
yield raiden_apps
shutdown_apps_and_cleanup_tasks(raiden_apps)
def raiden_network(
token_addresses,
token_network_registry_address,
one_to_n_address,
channels_per_node,
deposit,
settle_timeout,
chain_id,
blockchain_services,
endpoint_discovery_services,
raiden_udp_ports,
reveal_timeout,
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_servers,
private_rooms,
blockchain_type,
contracts_path,
user_deposit_address,
global_rooms,
tmpdir,
request,
):
service_registry_address = None
if blockchain_services.service_registry:
service_registry_address = blockchain_services.service_registry.address
if _ETH_LOGDIR:
base_datadir = os.path.join(_ETH_LOGDIR, request.node.name, "raiden_nodes")
else:
base_datadir = os.path.join(tmpdir.strpath, "raiden_nodes")
raiden_apps = create_apps(
chain_id=chain_id,
contracts_path=contracts_path,
blockchain_services=blockchain_services.blockchain_services,
endpoint_discovery_services=endpoint_discovery_services,
token_network_registry_address=token_network_registry_address,
secret_registry_address=blockchain_services.secret_registry.address,
service_registry_address=service_registry_address,
one_to_n_address=one_to_n_address,
user_deposit_address=user_deposit_address,
raiden_udp_ports=raiden_udp_ports,
reveal_timeout=reveal_timeout,
settle_timeout=settle_timeout,
database_basedir=base_datadir,
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,
environment_type=environment_type,
unrecoverable_error_should_crash=unrecoverable_error_should_crash,
local_matrix_url=local_matrix_servers[0],
private_rooms=private_rooms,
global_rooms=global_rooms,
)
confirmed_block = raiden_apps[0].raiden.confirmation_blocks + 1
blockchain_services.deploy_service.wait_until_block(target_block_number=confirmed_block)
parallel_start_apps(raiden_apps)
exception = RuntimeError("`raiden_chain` fixture setup failed, token networks unavailable")
with gevent.Timeout(seconds=timeout(blockchain_type), exception=exception):
wait_for_token_networks(
raiden_apps=raiden_apps,
token_network_registry_address=token_network_registry_address,
token_addresses=token_addresses,
)
app_channels = create_network_channels(raiden_apps, channels_per_node)
create_all_channels_for_network(
app_channels=app_channels,
token_addresses=token_addresses,
channel_individual_deposit=deposit,
channel_settle_timeout=settle_timeout,
)
exception = RuntimeError("`raiden_network` fixture setup failed, nodes are unreachable")
with gevent.Timeout(seconds=timeout(blockchain_type), exception=exception):
wait_for_channels(
app_channels, blockchain_services.deploy_registry.address, token_addresses, deposit
)
# Force blocknumber update
exception = RuntimeError("Alarm failed to start and set up start_block correctly")
with gevent.Timeout(seconds=5, exception=exception):
wait_for_alarm_start(raiden_apps)
yield raiden_apps
shutdown_apps_and_cleanup_tasks(raiden_apps)
def raiden_chain(
token_addresses,
token_network_registry_address,
one_to_n_address,
channels_per_node,
deposit,
settle_timeout,
chain_id,
blockchain_services,
endpoint_discovery_services,
raiden_udp_ports,
reveal_timeout,
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_servers,
private_rooms,
blockchain_type,
contracts_path,
user_deposit_address,
global_rooms,
tmpdir,
request,
):
if len(token_addresses) != 1:
raise ValueError("raiden_chain only works with a single token")
assert channels_per_node in (0, 1, 2, CHAIN), (
"deployed_network uses create_sequential_network that can only work "
"with 0, 1 or 2 channels"
)
if _ETH_LOGDIR:
base_datadir = os.path.join(_ETH_LOGDIR, request.node.name, "raiden_nodes")
else:
base_datadir = os.path.join(tmpdir.strpath, "raiden_nodes")
service_registry_address = None
if blockchain_services.service_registry:
service_registry_address = blockchain_services.service_registry.address
raiden_apps = create_apps(
chain_id=chain_id,
blockchain_services=blockchain_services.blockchain_services,
endpoint_discovery_services=endpoint_discovery_services,
token_network_registry_address=token_network_registry_address,
one_to_n_address=one_to_n_address,
secret_registry_address=blockchain_services.secret_registry.address,
service_registry_address=service_registry_address,
user_deposit_address=user_deposit_address,
raiden_udp_ports=raiden_udp_ports,
reveal_timeout=reveal_timeout,
settle_timeout=settle_timeout,
database_basedir=base_datadir,
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,
environment_type=environment_type,
unrecoverable_error_should_crash=unrecoverable_error_should_crash,
local_matrix_url=local_matrix_servers[0],
private_rooms=private_rooms,
contracts_path=contracts_path,
global_rooms=global_rooms,
)
confirmed_block = raiden_apps[0].raiden.confirmation_blocks + 1
blockchain_services.deploy_service.wait_until_block(target_block_number=confirmed_block)
parallel_start_apps(raiden_apps)
from_block = GENESIS_BLOCK_NUMBER
for app in raiden_apps:
app.raiden.install_all_blockchain_filters(
app.raiden.default_registry, app.raiden.default_secret_registry, from_block
)
exception = RuntimeError("`raiden_chain` fixture setup failed, token networks unavailable")
with gevent.Timeout(seconds=timeout(blockchain_type), exception=exception):
wait_for_token_networks(
raiden_apps=raiden_apps,
token_network_registry_address=token_network_registry_address,
token_addresses=token_addresses,
)
app_channels = create_sequential_channels(raiden_apps, channels_per_node)
create_all_channels_for_network(
app_channels=app_channels,
token_addresses=token_addresses,
channel_individual_deposit=deposit,
channel_settle_timeout=settle_timeout,
)
exception = RuntimeError("`raiden_chain` fixture setup failed, nodes are unreachable")
with gevent.Timeout(seconds=timeout(blockchain_type), exception=exception):
wait_for_channels(
app_channels, blockchain_services.deploy_registry.address, token_addresses, deposit
)
yield raiden_apps
shutdown_apps_and_cleanup_tasks(raiden_apps)
def raiden_network(
token_addresses,
token_network_registry_address,
channels_per_node,
deposit,
settle_timeout,
chain_id,
blockchain_services,
endpoint_discovery_services,
raiden_udp_ports,
reveal_timeout,
database_paths,
retry_interval,
retries_before_backoff,
throttle_capacity,
throttle_fill_rate,
nat_invitation_timeout,
nat_keepalive_retries,
nat_keepalive_timeout,
local_matrix_server,
):
raiden_apps = create_apps(
chain_id,
blockchain_services.blockchain_services,
endpoint_discovery_services,
token_network_registry_address,
blockchain_services.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,
local_matrix_server,
)
app_channels = create_network_channels(
raiden_apps,
channels_per_node,
)
greenlets = []
for token_address in token_addresses:
for app_pair in app_channels:
greenlets.append(gevent.spawn(
payment_channel_open_and_deposit,
app_pair[0],
app_pair[1],
token_address,
deposit,
settle_timeout,
))
gevent.wait(greenlets)
exception = RuntimeError('`raiden_network` fixture setup failed, nodes are unreachable')
with gevent.Timeout(seconds=30, exception=exception):
wait_for_channels(
app_channels,
blockchain_services.deploy_registry.address,
token_addresses,
deposit,
)
# Force blocknumber update
exception = RuntimeError('Alarm failed to start and set up start_block correctly')
with gevent.Timeout(seconds=5, exception=exception):
wait_for_alarm_start(raiden_apps)
yield raiden_apps
shutdown_apps_and_cleanup_tasks(raiden_apps)
def raiden_chain(
token_addresses,
token_network_registry_address,
channels_per_node,
deposit,
settle_timeout,
chain_id,
blockchain_services,
endpoint_discovery_services,
raiden_udp_ports,
reveal_timeout,
database_paths,
retry_interval,
retries_before_backoff,
throttle_capacity,
throttle_fill_rate,
nat_invitation_timeout,
nat_keepalive_retries,
nat_keepalive_timeout,
local_matrix_server,
):
if len(token_addresses) != 1:
raise ValueError('raiden_chain only works with a single token')
assert channels_per_node in (0, 1, 2, CHAIN), (
'deployed_network uses create_sequential_network that can only work '
'with 0, 1 or 2 channels'
)
raiden_apps = create_apps(
chain_id,
blockchain_services.blockchain_services,
endpoint_discovery_services,
token_network_registry_address,
blockchain_services.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,
local_matrix_server,
)
from_block = 0
for app in raiden_apps:
app.raiden.install_all_blockchain_filters(
app.raiden.default_registry,
app.raiden.default_secret_registry,
from_block,
)
app_channels = create_sequential_channels(
raiden_apps,
channels_per_node,
)
greenlets = []
for token_address in token_addresses:
for app_pair in app_channels:
greenlets.append(gevent.spawn(
payment_channel_open_and_deposit,
app_pair[0],
app_pair[1],
token_address,
deposit,
settle_timeout,
))
gevent.wait(greenlets)
exception = RuntimeError('`raiden_chain` fixture setup failed, nodes are unreachable')
with gevent.Timeout(seconds=30, exception=exception):
wait_for_channels(
app_channels,
blockchain_services.deploy_registry.address,
token_addresses,
deposit,
)
yield raiden_apps
shutdown_apps_and_cleanup_tasks(raiden_apps)
def raiden_network(
token_addresses: List[TokenAddress],
token_network_registry_address: TokenNetworkRegistryAddress,
one_to_n_address: OneToNAddress,
channels_per_node: int,
deposit: TokenAmount,
settle_timeout: BlockTimeout,
chain_id: ChainID,
blockchain_services: BlockchainServices,
reveal_timeout: BlockTimeout,
retry_interval: float,
retries_before_backoff: int,
environment_type: Environment,
unrecoverable_error_should_crash: bool,
local_matrix_servers: List[ParsedURL],
blockchain_type: str,
contracts_path: Path,
user_deposit_address: UserDepositAddress,
monitoring_service_contract_address: MonitoringServiceAddress,
broadcast_rooms: List[str],
logs_storage: str,
start_raiden_apps: bool,
routing_mode: RoutingMode,
blockchain_query_interval: float,
resolver_ports: List[Optional[int]],
) -> Iterable[List[App]]:
service_registry_address = None
if blockchain_services.service_registry:
service_registry_address = blockchain_services.service_registry.address
base_datadir = os.path.join(logs_storage, "raiden_nodes")
raiden_apps = create_apps(
chain_id=chain_id,
contracts_path=contracts_path,
blockchain_services=blockchain_services.blockchain_services,
token_network_registry_address=token_network_registry_address,
secret_registry_address=blockchain_services.secret_registry.address,
service_registry_address=service_registry_address,
one_to_n_address=one_to_n_address,
user_deposit_address=user_deposit_address,
monitoring_service_contract_address=monitoring_service_contract_address,
reveal_timeout=reveal_timeout,
settle_timeout=settle_timeout,
database_basedir=base_datadir,
retry_interval=retry_interval,
retries_before_backoff=retries_before_backoff,
environment_type=environment_type,
unrecoverable_error_should_crash=unrecoverable_error_should_crash,
local_matrix_url=local_matrix_servers[0],
broadcast_rooms=broadcast_rooms,
routing_mode=routing_mode,
blockchain_query_interval=blockchain_query_interval,
resolver_ports=resolver_ports,
)
confirmed_block = raiden_apps[0].raiden.confirmation_blocks + 1
blockchain_services.proxy_manager.client.wait_until_block(
target_block_number=confirmed_block)
if start_raiden_apps:
parallel_start_apps(raiden_apps)
exception = RuntimeError(
"`raiden_chain` fixture setup failed, token networks unavailable")
with gevent.Timeout(seconds=timeout(blockchain_type),
exception=exception):
wait_for_token_networks(
raiden_apps=raiden_apps,
token_network_registry_address=token_network_registry_address,
token_addresses=token_addresses,
)
app_channels = create_network_channels(raiden_apps, channels_per_node)
create_all_channels_for_network(
app_channels=app_channels,
token_addresses=token_addresses,
channel_individual_deposit=deposit,
channel_settle_timeout=settle_timeout,
)
if start_raiden_apps:
exception = RuntimeError(
"`raiden_network` fixture setup failed, nodes are unreachable")
with gevent.Timeout(seconds=timeout(blockchain_type),
exception=exception):
wait_for_channels(
app_channels=app_channels,
token_network_registry_address=blockchain_services.
deploy_registry.address,
token_addresses=token_addresses,
deposit=deposit,
)
# Force blocknumber update
exception = RuntimeError(
"Alarm failed to start and set up start_block correctly")
with gevent.Timeout(seconds=5, exception=exception):
wait_for_alarm_start(raiden_apps)
yield raiden_apps
shutdown_apps_and_cleanup_tasks(raiden_apps)
def raiden_chain(
token_addresses: List[TokenAddress],
token_network_registry_address: TokenNetworkRegistryAddress,
one_to_n_address: Optional[OneToNAddress],
monitoring_service_address: MonitoringServiceAddress,
channels_per_node: int,
deposit: TokenAmount,
settle_timeout: BlockTimeout,
chain_id: ChainID,
blockchain_services: BlockchainServices,
reveal_timeout: BlockTimeout,
retry_interval_initial: float,
retry_interval_max: float,
retries_before_backoff: int,
environment_type: Environment,
unrecoverable_error_should_crash: bool,
local_matrix_servers: List[ParsedURL],
blockchain_type: str,
contracts_path: Path,
user_deposit_address: UserDepositAddress,
broadcast_rooms: List[str],
logs_storage: str,
register_tokens: bool,
start_raiden_apps: bool,
routing_mode: RoutingMode,
blockchain_query_interval: float,
resolver_ports: List[Optional[int]],
enable_rest_api: bool,
port_generator: Iterator[Port],
capabilities: CapabilitiesConfig,
) -> Iterable[List[RaidenService]]:
if len(token_addresses) != 1:
raise ValueError("raiden_chain only works with a single token")
assert channels_per_node in (0, 1, 2, CHAIN), (
"deployed_network uses create_sequential_network that can only work "
"with 0, 1 or 2 channels"
)
base_datadir = os.path.join(logs_storage, "raiden_nodes")
service_registry_address: Optional[ServiceRegistryAddress] = None
if blockchain_services.service_registry:
service_registry_address = blockchain_services.service_registry.address
raiden_apps = create_apps(
chain_id=chain_id,
blockchain_services=blockchain_services.blockchain_services,
token_network_registry_address=token_network_registry_address,
one_to_n_address=one_to_n_address,
secret_registry_address=blockchain_services.secret_registry.address,
service_registry_address=service_registry_address,
user_deposit_address=user_deposit_address,
monitoring_service_contract_address=monitoring_service_address,
reveal_timeout=reveal_timeout,
settle_timeout=settle_timeout,
database_basedir=base_datadir,
retry_interval_initial=retry_interval_initial,
retry_interval_max=retry_interval_max,
retries_before_backoff=retries_before_backoff,
environment_type=environment_type,
unrecoverable_error_should_crash=unrecoverable_error_should_crash,
local_matrix_url=local_matrix_servers[0],
contracts_path=contracts_path,
broadcast_rooms=broadcast_rooms,
routing_mode=routing_mode,
blockchain_query_interval=blockchain_query_interval,
resolver_ports=resolver_ports,
enable_rest_api=enable_rest_api,
port_generator=port_generator,
capabilities_config=capabilities,
)
confirmed_block = BlockNumber(raiden_apps[0].confirmation_blocks + 1)
blockchain_services.proxy_manager.client.wait_until_block(target_block_number=confirmed_block)
if start_raiden_apps:
parallel_start_apps(raiden_apps)
if register_tokens:
exception = RuntimeError(
"`raiden_chain` fixture setup failed, token networks unavailable"
)
with gevent.Timeout(seconds=timeout(blockchain_type), exception=exception):
wait_for_token_networks(
raiden_apps=raiden_apps,
token_network_registry_address=token_network_registry_address,
token_addresses=token_addresses,
)
app_channels = create_sequential_channels(raiden_apps, channels_per_node)
create_all_channels_for_network(
app_channels=app_channels,
token_addresses=token_addresses,
channel_individual_deposit=deposit,
channel_settle_timeout=settle_timeout,
)
if start_raiden_apps:
exception = RuntimeError("`raiden_chain` fixture setup failed, nodes are unreachable")
with gevent.Timeout(seconds=timeout(blockchain_type), exception=exception):
wait_for_channels(
app_channels=app_channels,
token_network_registry_address=blockchain_services.deploy_registry.address,
token_addresses=token_addresses,
deposit=deposit,
)
yield raiden_apps
shutdown_apps_and_cleanup_tasks(raiden_apps)
def raiden_network(
request,
token_addresses,
channels_per_node,
deposit,
settle_timeout,
blockchain_services,
endpoint_discovery_services,
raiden_udp_ports,
reveal_timeout,
database_paths,
retry_interval,
retries_before_backoff,
throttle_capacity,
throttle_fill_rate,
nat_invitation_timeout,
nat_keepalive_retries,
nat_keepalive_timeout,
local_matrix_server,
):
raiden_apps = create_apps(
blockchain_services.blockchain_services,
endpoint_discovery_services,
blockchain_services.deploy_registry.address,
blockchain_services.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,
local_matrix_server,
)
app_channels = create_network_channels(
raiden_apps,
channels_per_node,
)
greenlets = []
for token_address in token_addresses:
for app_pair in app_channels:
greenlets.append(
gevent.spawn(
netting_channel_open_and_deposit,
app_pair[0],
app_pair[1],
token_address,
deposit,
settle_timeout,
))
gevent.wait(greenlets)
exception = RuntimeError(
'`raiden_network` fixture setup failed, nodes are unreachable')
with gevent.Timeout(seconds=30, exception=exception):
wait_for_channels(
app_channels,
blockchain_services.deploy_registry.address,
token_addresses,
deposit,
)
# Force blocknumber update
exception = RuntimeError(
'Alarm failed to start and set up start_block correctly')
with gevent.Timeout(seconds=5, exception=exception):
wait_for_alarm_start(raiden_apps)
for app in raiden_apps:
app.raiden.alarm.poll_for_new_block()
yield raiden_apps
shutdown_apps_and_cleanup_tasks(raiden_apps)
def raiden_chain(
request,
token_addresses,
channels_per_node,
deposit,
settle_timeout,
blockchain_services,
endpoint_discovery_services,
raiden_udp_ports,
reveal_timeout,
database_paths,
retry_interval,
retries_before_backoff,
throttle_capacity,
throttle_fill_rate,
nat_invitation_timeout,
nat_keepalive_retries,
nat_keepalive_timeout,
local_matrix_server,
):
if len(token_addresses) != 1:
raise ValueError('raiden_chain only works with a single token')
assert channels_per_node in (0, 1, 2, CHAIN), (
'deployed_network uses create_sequential_network that can only work '
'with 0, 1 or 2 channels')
raiden_apps = create_apps(
blockchain_services.blockchain_services,
endpoint_discovery_services,
blockchain_services.deploy_registry.address,
blockchain_services.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,
local_matrix_server,
)
for app in raiden_apps:
app.raiden.install_and_query_payment_network_filters(
app.raiden.default_registry.address)
app_channels = create_sequential_channels(
raiden_apps,
channels_per_node,
)
greenlets = []
for token_address in token_addresses:
for app_pair in app_channels:
greenlets.append(
gevent.spawn(
netting_channel_open_and_deposit,
app_pair[0],
app_pair[1],
token_address,
deposit,
settle_timeout,
))
gevent.wait(greenlets)
exception = RuntimeError(
'`raiden_chain` fixture setup failed, nodes are unreachable')
with gevent.Timeout(seconds=30, exception=exception):
wait_for_channels(
app_channels,
blockchain_services.deploy_registry.address,
token_addresses,
deposit,
)
yield raiden_apps
shutdown_apps_and_cleanup_tasks(raiden_apps)
def raiden_chain(
token_addresses: List[TokenAddress],
token_network_registry_address: TokenNetworkRegistryAddress,
one_to_n_address: Address,
channels_per_node: int,
deposit: TokenAmount,
settle_timeout: BlockTimeout,
chain_id: ChainID,
blockchain_services: BlockchainServices,
reveal_timeout: BlockTimeout,
retry_interval: float,
retries_before_backoff: int,
environment_type: Environment,
unrecoverable_error_should_crash: bool,
local_matrix_servers: List[ParsedURL],
private_rooms: bool,
blockchain_type: str,
contracts_path: str,
user_deposit_address: Address,
monitoring_service_contract_address: Address,
global_rooms: List[str],
logs_storage: str,
routing_mode: RoutingMode,
blockchain_query_interval: float,
resolver_ports: List[Optional[int]],
) -> Iterable[List[App]]:
if len(token_addresses) != 1:
raise ValueError("raiden_chain only works with a single token")
assert channels_per_node in (0, 1, 2, CHAIN), (
"deployed_network uses create_sequential_network that can only work "
"with 0, 1 or 2 channels")
base_datadir = os.path.join(logs_storage, "raiden_nodes")
service_registry_address: Optional[Address] = None
if blockchain_services.service_registry:
service_registry_address = blockchain_services.service_registry.address
raiden_apps = create_apps(
chain_id=chain_id,
blockchain_services=blockchain_services.blockchain_services,
token_network_registry_address=token_network_registry_address,
one_to_n_address=one_to_n_address,
secret_registry_address=blockchain_services.secret_registry.address,
service_registry_address=service_registry_address,
user_deposit_address=user_deposit_address,
monitoring_service_contract_address=monitoring_service_contract_address,
reveal_timeout=reveal_timeout,
settle_timeout=settle_timeout,
database_basedir=base_datadir,
retry_interval=retry_interval,
retries_before_backoff=retries_before_backoff,
environment_type=environment_type,
unrecoverable_error_should_crash=unrecoverable_error_should_crash,
local_matrix_url=local_matrix_servers[0],
private_rooms=private_rooms,
contracts_path=contracts_path,
global_rooms=global_rooms,
routing_mode=routing_mode,
blockchain_query_interval=blockchain_query_interval,
resolver_ports=resolver_ports,
)
confirmed_block = raiden_apps[0].raiden.confirmation_blocks + 1
blockchain_services.proxy_manager.wait_until_block(
target_block_number=confirmed_block)
parallel_start_apps(raiden_apps)
from_block = GENESIS_BLOCK_NUMBER
for app in raiden_apps:
app.raiden.install_all_blockchain_filters(
app.raiden.default_registry, app.raiden.default_secret_registry,
from_block)
exception = RuntimeError(
"`raiden_chain` fixture setup failed, token networks unavailable")
with gevent.Timeout(seconds=timeout(blockchain_type), exception=exception):
wait_for_token_networks(
raiden_apps=raiden_apps,
token_network_registry_address=token_network_registry_address,
token_addresses=token_addresses,
)
app_channels = create_sequential_channels(raiden_apps, channels_per_node)
create_all_channels_for_network(
app_channels=app_channels,
token_addresses=token_addresses,
channel_individual_deposit=deposit,
channel_settle_timeout=settle_timeout,
)
exception = RuntimeError(
"`raiden_chain` fixture setup failed, nodes are unreachable")
with gevent.Timeout(seconds=timeout(blockchain_type), exception=exception):
wait_for_channels(
app_channels=app_channels,
token_network_registry_address=blockchain_services.deploy_registry.
address,
token_addresses=token_addresses,
deposit=deposit,
)
yield raiden_apps
shutdown_apps_and_cleanup_tasks(raiden_apps)
def raiden_chain(
token_addresses,
token_network_registry_address,
channels_per_node,
deposit,
settle_timeout,
chain_id,
blockchain_services,
endpoint_discovery_services,
raiden_udp_ports,
reveal_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_servers,
private_rooms,
retry_timeout,
):
if len(token_addresses) != 1:
raise ValueError('raiden_chain only works with a single token')
assert channels_per_node in (0, 1, 2, CHAIN), (
'deployed_network uses create_sequential_network that can only work '
'with 0, 1 or 2 channels'
)
raiden_apps = create_apps(
chain_id=chain_id,
blockchain_services=blockchain_services.blockchain_services,
endpoint_discovery_services=endpoint_discovery_services,
token_network_registry_address=token_network_registry_address,
secret_registry_address=blockchain_services.secret_registry.address,
raiden_udp_ports=raiden_udp_ports,
reveal_timeout=reveal_timeout,
settle_timeout=settle_timeout,
database_paths=database_paths,
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,
environment_type=environment_type,
unrecoverable_error_should_crash=unrecoverable_error_should_crash,
local_matrix_url=local_matrix_servers[0],
private_rooms=private_rooms,
)
start_tasks = [gevent.spawn(app.raiden.start) for app in raiden_apps]
gevent.joinall(start_tasks, raise_error=True)
from_block = GENESIS_BLOCK_NUMBER
for app in raiden_apps:
app.raiden.install_all_blockchain_filters(
app.raiden.default_registry,
app.raiden.default_secret_registry,
from_block,
)
exception = RuntimeError('`raiden_chain` fixture setup failed, token networks unavailable')
with gevent.Timeout(seconds=30, exception=exception):
wait_for_token_networks(
raiden_apps=raiden_apps,
token_network_registry_address=token_network_registry_address,
token_addresses=token_addresses,
)
app_channels = create_sequential_channels(
raiden_apps,
channels_per_node,
)
create_all_channels_for_network(
app_channels=app_channels,
token_addresses=token_addresses,
channel_individual_deposit=deposit,
channel_settle_timeout=settle_timeout,
token_network_registry_address=token_network_registry_address,
retry_timeout=retry_timeout,
)
exception = RuntimeError('`raiden_chain` fixture setup failed, nodes are unreachable')
with gevent.Timeout(seconds=30, exception=exception):
wait_for_channels(
app_channels,
blockchain_services.deploy_registry.address,
token_addresses,
deposit,
)
yield raiden_apps
shutdown_apps_and_cleanup_tasks(raiden_apps)
def raiden_network(
token_addresses,
token_network_registry_address,
channels_per_node,
deposit,
settle_timeout,
chain_id,
blockchain_services,
endpoint_discovery_services,
raiden_udp_ports,
reveal_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_servers,
private_rooms,
retry_timeout,
):
raiden_apps = create_apps(
chain_id=chain_id,
blockchain_services=blockchain_services.blockchain_services,
endpoint_discovery_services=endpoint_discovery_services,
token_network_registry_address=token_network_registry_address,
secret_registry_address=blockchain_services.secret_registry.address,
raiden_udp_ports=raiden_udp_ports,
reveal_timeout=reveal_timeout,
settle_timeout=settle_timeout,
database_paths=database_paths,
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,
environment_type=environment_type,
unrecoverable_error_should_crash=unrecoverable_error_should_crash,
local_matrix_url=local_matrix_servers[0],
private_rooms=private_rooms,
)
start_tasks = [gevent.spawn(app.raiden.start) for app in raiden_apps]
gevent.joinall(start_tasks, raise_error=True)
exception = RuntimeError('`raiden_chain` fixture setup failed, token networks unavailable')
with gevent.Timeout(seconds=30, exception=exception):
wait_for_token_networks(
raiden_apps=raiden_apps,
token_network_registry_address=token_network_registry_address,
token_addresses=token_addresses,
)
app_channels = create_network_channels(
raiden_apps,
channels_per_node,
)
create_all_channels_for_network(
app_channels=app_channels,
token_addresses=token_addresses,
channel_individual_deposit=deposit,
channel_settle_timeout=settle_timeout,
token_network_registry_address=token_network_registry_address,
retry_timeout=retry_timeout,
)
exception = RuntimeError('`raiden_network` fixture setup failed, nodes are unreachable')
with gevent.Timeout(seconds=30, exception=exception):
wait_for_channels(
app_channels,
blockchain_services.deploy_registry.address,
token_addresses,
deposit,
)
# Force blocknumber update
exception = RuntimeError('Alarm failed to start and set up start_block correctly')
with gevent.Timeout(seconds=5, exception=exception):
wait_for_alarm_start(raiden_apps)
yield raiden_apps
shutdown_apps_and_cleanup_tasks(raiden_apps)
def raiden_chain(
token_addresses,
token_network_registry_address,
channels_per_node,
deposit,
settle_timeout,
chain_id,
blockchain_services,
endpoint_discovery_services,
raiden_udp_ports,
reveal_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_servers,
private_rooms,
retry_timeout,
blockchain_type,
):
if len(token_addresses) != 1:
raise ValueError('raiden_chain only works with a single token')
assert channels_per_node in (0, 1, 2, CHAIN), (
'deployed_network uses create_sequential_network that can only work '
'with 0, 1 or 2 channels')
raiden_apps = create_apps(
chain_id=chain_id,
blockchain_services=blockchain_services.blockchain_services,
endpoint_discovery_services=endpoint_discovery_services,
token_network_registry_address=token_network_registry_address,
secret_registry_address=blockchain_services.secret_registry.address,
raiden_udp_ports=raiden_udp_ports,
reveal_timeout=reveal_timeout,
settle_timeout=settle_timeout,
database_paths=database_paths,
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,
environment_type=environment_type,
unrecoverable_error_should_crash=unrecoverable_error_should_crash,
local_matrix_url=local_matrix_servers[0],
private_rooms=private_rooms,
)
wait_for_confirmed_block(blockchain_services, raiden_apps)
parallel_start_apps(raiden_apps)
from_block = GENESIS_BLOCK_NUMBER
for app in raiden_apps:
app.raiden.install_all_blockchain_filters(
app.raiden.default_registry,
app.raiden.default_secret_registry,
from_block,
)
exception = RuntimeError(
'`raiden_chain` fixture setup failed, token networks unavailable')
with gevent.Timeout(seconds=timeout(blockchain_type), exception=exception):
wait_for_token_networks(
raiden_apps=raiden_apps,
token_network_registry_address=token_network_registry_address,
token_addresses=token_addresses,
)
app_channels = create_sequential_channels(
raiden_apps,
channels_per_node,
)
create_all_channels_for_network(
app_channels=app_channels,
token_addresses=token_addresses,
channel_individual_deposit=deposit,
channel_settle_timeout=settle_timeout,
token_network_registry_address=token_network_registry_address,
retry_timeout=retry_timeout,
)
exception = RuntimeError(
'`raiden_chain` fixture setup failed, nodes are unreachable')
with gevent.Timeout(seconds=timeout(blockchain_type), exception=exception):
wait_for_channels(
app_channels,
blockchain_services.deploy_registry.address,
token_addresses,
deposit,
)
yield raiden_apps
shutdown_apps_and_cleanup_tasks(raiden_apps)
def raiden_network(
token_addresses,
token_network_registry_address,
channels_per_node,
deposit,
settle_timeout,
chain_id,
blockchain_services,
endpoint_discovery_services,
raiden_udp_ports,
reveal_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_servers,
private_rooms,
retry_timeout,
blockchain_type,
):
raiden_apps = create_apps(
chain_id=chain_id,
blockchain_services=blockchain_services.blockchain_services,
endpoint_discovery_services=endpoint_discovery_services,
token_network_registry_address=token_network_registry_address,
secret_registry_address=blockchain_services.secret_registry.address,
raiden_udp_ports=raiden_udp_ports,
reveal_timeout=reveal_timeout,
settle_timeout=settle_timeout,
database_paths=database_paths,
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,
environment_type=environment_type,
unrecoverable_error_should_crash=unrecoverable_error_should_crash,
local_matrix_url=local_matrix_servers[0],
private_rooms=private_rooms,
)
wait_for_confirmed_block(blockchain_services, raiden_apps)
parallel_start_apps(raiden_apps)
exception = RuntimeError(
'`raiden_chain` fixture setup failed, token networks unavailable')
with gevent.Timeout(seconds=timeout(blockchain_type), exception=exception):
wait_for_token_networks(
raiden_apps=raiden_apps,
token_network_registry_address=token_network_registry_address,
token_addresses=token_addresses,
)
app_channels = create_network_channels(
raiden_apps,
channels_per_node,
)
create_all_channels_for_network(
app_channels=app_channels,
token_addresses=token_addresses,
channel_individual_deposit=deposit,
channel_settle_timeout=settle_timeout,
token_network_registry_address=token_network_registry_address,
retry_timeout=retry_timeout,
)
exception = RuntimeError(
'`raiden_network` fixture setup failed, nodes are unreachable')
with gevent.Timeout(seconds=timeout(blockchain_type), exception=exception):
wait_for_channels(
app_channels,
blockchain_services.deploy_registry.address,
token_addresses,
deposit,
)
# Force blocknumber update
exception = RuntimeError(
'Alarm failed to start and set up start_block correctly')
with gevent.Timeout(seconds=5, exception=exception):
wait_for_alarm_start(raiden_apps)
yield raiden_apps
shutdown_apps_and_cleanup_tasks(raiden_apps)
