def __init__(
self,
config: typing.Dict,
chain: BlockChainService,
query_start_block: typing.BlockNumber,
default_registry: TokenNetworkRegistry,
default_secret_registry: SecretRegistry,
transport,
raiden_event_handler,
message_handler,
discovery: Discovery = None,
):
raiden = RaidenService(
chain=chain,
query_start_block=query_start_block,
default_registry=default_registry,
default_secret_registry=default_secret_registry,
private_key_bin=unhexlify(config['privatekey_hex']),
transport=transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
config=config,
discovery=discovery,
)
# Check if files with older versions of the DB exist, emit a warning
db_base_path = os.path.dirname(config['database_path'])
if older_db_files_exist(db_base_path):
log.warning(
'Older versions of the database exist in '
f'{db_base_path}. Since a newer breaking version is introduced, '
'it is advised that you leave all token networks before upgrading and '
'then proceed with the upgrade.', )
# check that the settlement timeout fits the limits of the contract
invalid_settle_timeout = (
config['settle_timeout'] <
default_registry.settlement_timeout_min()
or config['settle_timeout'] >
default_registry.settlement_timeout_max()
or config['settle_timeout'] < config['reveal_timeout'] * 2)
if invalid_settle_timeout:
raise InvalidSettleTimeout(
('Settlement timeout for Registry contract {} must '
'be in range [{}, {}], is {}').format(
to_checksum_address(default_registry.address),
default_registry.settlement_timeout_min(),
default_registry.settlement_timeout_max(),
config['settle_timeout'],
), )
self.config = config
self.discovery = discovery
self.raiden = raiden
self.start_console = self.config['console']
# raiden.ui.console:Console assumes that a services
# attribute is available for auto-registration
self.services = dict()
def setup_testchain_and_raiden(smoketest_config, transport, matrix_server,
print_step):
print_step('Starting Ethereum node')
ethereum, ethereum_config = start_ethereum(smoketest_config['genesis'])
port = ethereum_config['rpc']
web3_client = Web3(HTTPProvider(f'http://0.0.0.0:{port}'))
web3_client.middleware_stack.inject(geth_poa_middleware, layer=0)
random_marker = hexlify(b'raiden').decode()
privatekeys = []
geth_wait_and_check(web3_client, privatekeys, random_marker)
print_step('Deploying Raiden contracts')
host = '0.0.0.0'
client = JSONRPCClient(
host,
ethereum_config['rpc'],
get_private_key(),
web3=web3_client,
)
contract_addresses = deploy_smoketest_contracts(client, 627)
token_contract = deploy_token(client)
token = token_contract(1000, 0, 'TKN', 'TKN')
registry = TokenNetworkRegistry(
client, contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY])
registry.add_token(to_canonical_address(token.contract.address))
print_step('Setting up Raiden')
# setup cli arguments for starting raiden
args = dict(
discovery_contract_address=to_checksum_address(
contract_addresses[CONTRACT_ENDPOINT_REGISTRY], ),
registry_contract_address=to_checksum_address(
contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY], ),
secret_registry_contract_address=to_checksum_address(
contract_addresses[CONTRACT_SECRET_REGISTRY], ),
eth_rpc_endpoint='http://127.0.0.1:{}'.format(port),
keystore_path=ethereum_config['keystore'],
address=ethereum_config['address'],
network_id='627',
sync_check=False,
transport=transport,
matrix_server='http://localhost:8008'
if matrix_server == 'auto' else matrix_server,
)
password_file = os.path.join(args['keystore_path'], 'password')
with open(password_file, 'w') as handler:
handler.write('password')
args['password_file'] = click.File()(password_file)
args['datadir'] = args['keystore_path']
return dict(
args=args,
contract_addresses=contract_addresses,
ethereum=ethereum,
ethereum_config=ethereum_config,
token=token,
)
def __init__(
self,
config: typing.Dict,
chain: BlockChainService,
query_start_block: typing.BlockNumber,
default_registry: TokenNetworkRegistry,
default_secret_registry: SecretRegistry,
transport,
discovery: Discovery = None,
):
self.config = config
self.discovery = discovery
# check that the settlement timeout fits the limits of the contract
invalid_timeout = (
config['settle_timeout'] < default_registry.settlement_timeout_min() or
config['settle_timeout'] > default_registry.settlement_timeout_max()
)
if invalid_timeout:
raise InvalidSettleTimeout(
(
'Settlement timeout for Registry contract {} must '
'be in range [{}, {}], is {}'
).format(
to_checksum_address(default_registry.address),
default_registry.settlement_timeout_min(),
default_registry.settlement_timeout_max(),
config['settle_timeout'],
),
)
try:
self.raiden = RaidenService(
chain=chain,
query_start_block=query_start_block,
default_registry=default_registry,
default_secret_registry=default_secret_registry,
private_key_bin=unhexlify(config['privatekey_hex']),
transport=transport,
config=config,
discovery=discovery,
)
except filelock.Timeout:
pubkey = to_normalized_address(
privatekey_to_address(unhexlify(self.config['privatekey_hex'])),
)
print(
f'FATAL: Another Raiden instance already running for account {pubkey} on '
f'network id {chain.network_id}',
)
sys.exit(1)
def __init__(
self,
config: typing.Dict,
chain: BlockChainService,
query_start_block: typing.BlockNumber,
default_registry: TokenNetworkRegistry,
default_secret_registry: SecretRegistry,
transport,
raiden_event_handler,
message_handler,
discovery: Discovery = None,
):
raiden = RaidenService(
chain=chain,
query_start_block=query_start_block,
default_registry=default_registry,
default_secret_registry=default_secret_registry,
transport=transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
config=config,
discovery=discovery,
)
# check that the settlement timeout fits the limits of the contract
invalid_settle_timeout = (
config['settle_timeout'] < default_registry.settlement_timeout_min() or
config['settle_timeout'] > default_registry.settlement_timeout_max() or
config['settle_timeout'] < config['reveal_timeout'] * 2
)
if invalid_settle_timeout:
raise InvalidSettleTimeout(
(
'Settlement timeout for Registry contract {} must '
'be in range [{}, {}], is {}'
).format(
to_checksum_address(default_registry.address),
default_registry.settlement_timeout_min(),
default_registry.settlement_timeout_max(),
config['settle_timeout'],
),
)
self.config = config
self.discovery = discovery
self.raiden = raiden
self.start_console = self.config['console']
# raiden.ui.console:Console assumes that a services
# attribute is available for auto-registration
self.services = dict()
def __init__(
self,
config: Dict,
chain: BlockChainService,
default_registry: TokenNetworkRegistry,
default_secret_registry: SecretRegistry,
transport,
discovery: Discovery = None,
):
self.config = config
self.discovery = discovery
# check that the settlement timeout fits the limits of the contract
invalid_timeout = (config['settle_timeout'] <
default_registry.settlement_timeout_min()
or config['settle_timeout'] >
default_registry.settlement_timeout_max())
if invalid_timeout:
raise InvalidSettleTimeout(
('Settlement timeout for Registry contract {} must '
'be in range [{}, {}], is {}').format(
to_checksum_address(default_registry.address),
default_registry.settlement_timeout_min(),
default_registry.settlement_timeout_max(),
config['settle_timeout'],
), )
try:
self.raiden = RaidenService(
chain,
default_registry,
default_secret_registry,
unhexlify(config['privatekey_hex']),
transport,
config,
discovery,
)
except filelock.Timeout:
pubkey = to_normalized_address(
privatekey_to_address(unhexlify(
self.config['privatekey_hex'])), )
print(
f'FATAL: Another Raiden instance already running for account {pubkey} on '
f'network id {chain.network_id}', )
sys.exit(1)
self.start_console = self.config['console']
# raiden.ui.console:Console assumes that a services
# attribute is available for auto-registration
self.services = dict()
def __init__(
self,
config: typing.Dict,
chain: BlockChainService,
query_start_block: typing.BlockNumber,
default_registry: TokenNetworkRegistry,
default_secret_registry: SecretRegistry,
transport,
discovery: Discovery = None,
):
self.config = config
self.discovery = discovery
# check that the settlement timeout fits the limits of the contract
invalid_timeout = (config['settle_timeout'] <
default_registry.settlement_timeout_min()
or config['settle_timeout'] >
default_registry.settlement_timeout_max())
if invalid_timeout:
raise InvalidSettleTimeout(
('Settlement timeout for Registry contract {} must '
'be in range [{}, {}], is {}').format(
to_checksum_address(default_registry.address),
default_registry.settlement_timeout_min(),
default_registry.settlement_timeout_max(),
config['settle_timeout'],
), )
try:
self.raiden = RaidenService(
chain=chain,
query_start_block=query_start_block,
default_registry=default_registry,
default_secret_registry=default_secret_registry,
private_key_bin=unhexlify(config['privatekey_hex']),
transport=transport,
config=config,
discovery=discovery,
)
except filelock.Timeout:
pubkey = to_normalized_address(
privatekey_to_address(unhexlify(
self.config['privatekey_hex'])), )
print(
f'FATAL: Another Raiden instance already running for account {pubkey} on '
f'network id {chain.network_id}', )
sys.exit(1)
def token_network_registry_proxy(deploy_client,
token_network_registry_contract,
contract_manager):
return TokenNetworkRegistry(
jsonrpc_client=deploy_client,
registry_address=to_canonical_address(
token_network_registry_contract.contract.address),
contract_manager=contract_manager,
)
def token_network_registry(self, address: Address) -> TokenNetworkRegistry:
if not is_binary_address(address):
raise ValueError('address must be a valid address')
if address not in self.address_to_token_network_registry:
self.address_to_token_network_registry[address] = TokenNetworkRegistry(
self.client,
address,
)
return self.address_to_token_network_registry[address]
def token_network_registry(self, address: Address) -> TokenNetworkRegistry:
if not is_binary_address(address):
raise ValueError('address must be a valid address')
with self._token_network_registry_creation_lock:
if address not in self.address_to_token_network_registry:
self.address_to_token_network_registry[address] = TokenNetworkRegistry(
jsonrpc_client=self.client,
registry_address=PaymentNetworkID(address),
contract_manager=self.contract_manager,
)
return self.address_to_token_network_registry[address]
def setup_raiden(
transport,
matrix_server,
print_step,
contracts_version,
testchain_setup,
):
print_step('Deploying Raiden contracts')
client = JSONRPCClient(testchain_setup['web3'],
get_private_key(testchain_setup['keystore']))
contract_manager = ContractManager(
contracts_precompiled_path(contracts_version), )
contract_addresses = deploy_smoketest_contracts(
client=client,
chain_id=NETWORKNAME_TO_ID['smoketest'],
contract_manager=contract_manager,
)
token = deploy_token(
deploy_client=client,
contract_manager=contract_manager,
initial_amount=1000,
decimals=0,
token_name='TKN',
token_symbol='TKN',
)
registry = TokenNetworkRegistry(
jsonrpc_client=client,
registry_address=contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY],
contract_manager=contract_manager,
)
registry.add_token(
token_address=to_canonical_address(token.contract.address),
given_block_identifier='latest',
)
print_step('Setting up Raiden')
endpoint_registry_contract_address = to_checksum_address(
contract_addresses[CONTRACT_ENDPOINT_REGISTRY], )
tokennetwork_registry_contract_address = to_checksum_address(
contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY], )
secret_registry_contract_address = to_checksum_address(
contract_addresses[CONTRACT_SECRET_REGISTRY], )
return {
'args': {
'address':
to_checksum_address(TEST_ACCOUNT_ADDRESS),
'datadir':
testchain_setup['keystore'],
'endpoint_registry_contract_address':
endpoint_registry_contract_address,
'eth_rpc_endpoint':
testchain_setup['eth_rpc_endpoint'],
'gas_price':
'fast',
'keystore_path':
testchain_setup['keystore'],
'matrix_server':
matrix_server,
'network_id':
str(NETWORKNAME_TO_ID['smoketest']),
'password_file':
click.File()(os.path.join(testchain_setup['base_datadir'], 'pw')),
'tokennetwork_registry_contract_address':
tokennetwork_registry_contract_address,
'secret_registry_contract_address':
secret_registry_contract_address,
'sync_check':
False,
'transport':
transport,
},
'contract_addresses': contract_addresses,
'ethereum': testchain_setup['processes_list'],
'token': token,
}
def setup_testchain_and_raiden(transport, matrix_server, print_step):
print_step('Starting Ethereum node')
ensure_executable('geth')
free_port = get_free_port('127.0.0.1', 27854)
rpc_port = next(free_port)
p2p_port = next(free_port)
base_datadir = os.environ['RST_DATADIR']
description = GethNodeDescription(
private_key=TEST_PRIVKEY,
rpc_port=rpc_port,
p2p_port=p2p_port,
miner=True,
)
eth_rpc_endpoint = f'http://127.0.0.1:{rpc_port}'
web3 = Web3(HTTPProvider(endpoint_uri=eth_rpc_endpoint))
web3.middleware_stack.inject(geth_poa_middleware, layer=0)
config = geth_node_config(
description.private_key,
description.p2p_port,
description.rpc_port,
)
config.update({
'unlock': 0,
'mine': True,
'password': os.path.join(base_datadir, 'pw'),
})
nodes_configuration = [config]
geth_node_config_set_bootnodes(nodes_configuration)
keystore = os.path.join(geth_node_to_datadir(config, base_datadir),
'keystore')
logdir = os.path.join(base_datadir, 'logs')
processes_list = geth_run_nodes(
geth_nodes=[description],
nodes_configuration=nodes_configuration,
base_datadir=base_datadir,
genesis_file=os.path.join(get_project_root(),
'smoketest_genesis.json'),
chain_id=NETWORKNAME_TO_ID['smoketest'],
verbosity=0,
logdir=logdir,
)
try:
# the marker is hardcoded in the genesis file
random_marker = remove_0x_prefix(encode_hex(b'raiden'))
geth_wait_and_check(web3, [], random_marker)
for process in processes_list:
process.poll()
if process.returncode is not None:
raise ValueError(
f'geth process failed with exit code {process.returncode}')
except (ValueError, RuntimeError) as e:
# If geth_wait_and_check or the above loop throw an exception make sure
# we don't end up with a rogue geth process running in the background
for process in processes_list:
process.terminate()
raise e
print_step('Deploying Raiden contracts')
client = JSONRPCClient(web3, get_private_key(keystore))
# for smoketest use the precompiled contracts
contract_manager = ContractManager(contracts_precompiled_path())
contract_addresses = deploy_smoketest_contracts(
client=client,
chain_id=NETWORKNAME_TO_ID['smoketest'],
contract_manager=contract_manager,
)
token = deploy_token(
deploy_client=client,
contract_manager=contract_manager,
initial_amount=1000,
decimals=0,
token_name='TKN',
token_symbol='TKN',
)
registry = TokenNetworkRegistry(
jsonrpc_client=client,
registry_address=contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY],
contract_manager=contract_manager,
)
registry.add_token(to_canonical_address(token.contract.address))
print_step('Setting up Raiden')
if matrix_server == 'auto':
matrix_server = 'http://localhost:8008'
endpoint_registry_contract_address = to_checksum_address(
contract_addresses[CONTRACT_ENDPOINT_REGISTRY], )
tokennetwork_registry_contract_address = to_checksum_address(
contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY], )
secret_registry_contract_address = to_checksum_address(
contract_addresses[CONTRACT_SECRET_REGISTRY], )
return {
'args': {
'address': to_checksum_address(TEST_ACCOUNT_ADDRESS),
'datadir': keystore,
'endpoint_registry_contract_address':
endpoint_registry_contract_address,
'eth_rpc_endpoint': eth_rpc_endpoint,
'gas_price': 'fast',
'keystore_path': keystore,
'matrix_server': matrix_server,
'network_id': str(NETWORKNAME_TO_ID['smoketest']),
'password_file': click.File()(os.path.join(base_datadir, 'pw')),
'tokennetwork_registry_contract_address':
tokennetwork_registry_contract_address,
'secret_registry_contract_address':
secret_registry_contract_address,
'sync_check': False,
'transport': transport,
},
'contract_addresses': contract_addresses,
'ethereum': processes_list,
'token': token,
}
def smoketest(ctx, debug, local_matrix, **kwargs): # pylint: disable=unused-argument
""" Test, that the raiden installation is sane. """
import binascii
from web3 import Web3, HTTPProvider
from web3.middleware import geth_poa_middleware
from raiden.api.python import RaidenAPI
from raiden.tests.utils.geth import geth_wait_and_check
from raiden.tests.integration.contracts.fixtures.contracts import deploy_token
from raiden.tests.utils.smoketest import (
TEST_PARTNER_ADDRESS,
TEST_DEPOSIT_AMOUNT,
deploy_smoketest_contracts,
get_private_key,
load_smoketest_config,
start_ethereum,
run_smoketests,
)
report_file = tempfile.mktemp(suffix='.log')
configure_logging({'': 'DEBUG'}, log_file=report_file)
def append_report(subject, data):
with open(report_file, 'a', encoding='UTF-8') as handler:
handler.write(f'{f" {subject.upper()} ":=^80}{os.linesep}')
if data is not None:
if isinstance(data, bytes):
data = data.decode()
handler.writelines([data + os.linesep])
append_report('Raiden version', json.dumps(get_system_spec()))
append_report('Raiden log', None)
step_count = 7
if ctx.parent.params['transport'] == 'matrix':
step_count = 8
step = 0
def print_step(description, error=False):
nonlocal step
step += 1
click.echo(
'{} {}'.format(
click.style(f'[{step}/{step_count}]', fg='blue'),
click.style(description, fg='green' if not error else 'red'),
), )
print_step('Getting smoketest configuration')
smoketest_config = load_smoketest_config()
if not smoketest_config:
append_report(
'Smoketest configuration',
'Could not load the smoketest genesis configuration file.',
)
print_step('Starting Ethereum node')
ethereum, ethereum_config = start_ethereum(smoketest_config['genesis'])
port = ethereum_config['rpc']
web3_client = Web3(HTTPProvider(f'http://0.0.0.0:{port}'))
web3_client.middleware_stack.inject(geth_poa_middleware, layer=0)
random_marker = binascii.hexlify(b'raiden').decode()
privatekeys = []
geth_wait_and_check(web3_client, privatekeys, random_marker)
print_step('Deploying Raiden contracts')
host = '0.0.0.0'
client = JSONRPCClient(
host,
ethereum_config['rpc'],
get_private_key(),
web3=web3_client,
)
contract_addresses = deploy_smoketest_contracts(client, 627)
token_contract = deploy_token(client)
token = token_contract(1000, 0, 'TKN', 'TKN')
registry = TokenNetworkRegistry(
client, contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY])
registry.add_token(to_canonical_address(token.contract.address))
print_step('Setting up Raiden')
# setup cli arguments for starting raiden
args = dict(
discovery_contract_address=to_checksum_address(
contract_addresses[CONTRACT_ENDPOINT_REGISTRY], ),
registry_contract_address=to_checksum_address(
contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY], ),
secret_registry_contract_address=to_checksum_address(
contract_addresses[CONTRACT_SECRET_REGISTRY], ),
eth_rpc_endpoint='http://127.0.0.1:{}'.format(port),
keystore_path=ethereum_config['keystore'],
address=ethereum_config['address'],
network_id='627',
transport=ctx.parent.params['transport'],
matrix_server='http://localhost:8008'
if ctx.parent.params['matrix_server'] == 'auto' else
ctx.parent.params['matrix_server'],
)
smoketest_config['transport'] = args['transport']
for option_ in app.params:
if option_.name in args.keys():
args[option_.name] = option_.process_value(ctx, args[option_.name])
else:
args[option_.name] = option_.default
password_file = os.path.join(args['keystore_path'], 'password')
with open(password_file, 'w') as handler:
handler.write('password')
port = next(get_free_port('127.0.0.1', 5001))
args['password_file'] = click.File()(password_file)
args['datadir'] = args['keystore_path']
args['api_address'] = 'localhost:' + str(port)
args['sync_check'] = False
def _run_smoketest():
print_step('Starting Raiden')
# invoke the raiden app
app_ = ctx.invoke(app, **args)
raiden_api = RaidenAPI(app_.raiden)
rest_api = RestAPI(raiden_api)
api_server = APIServer(rest_api)
(api_host, api_port) = split_endpoint(args['api_address'])
api_server.start(api_host, api_port)
raiden_api.channel_open(
contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY],
to_canonical_address(token.contract.address),
to_canonical_address(TEST_PARTNER_ADDRESS),
None,
None,
)
raiden_api.set_total_channel_deposit(
contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY],
to_canonical_address(token.contract.address),
to_canonical_address(TEST_PARTNER_ADDRESS),
TEST_DEPOSIT_AMOUNT,
)
smoketest_config['contracts'][
'registry_address'] = to_checksum_address(
contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY], )
smoketest_config['contracts'][
'secret_registry_address'] = to_checksum_address(
contract_addresses[CONTRACT_SECRET_REGISTRY], )
smoketest_config['contracts'][
'discovery_address'] = to_checksum_address(
contract_addresses[CONTRACT_ENDPOINT_REGISTRY], )
smoketest_config['contracts']['token_address'] = to_checksum_address(
token.contract.address, )
success = False
try:
print_step('Running smoketest')
error = run_smoketests(app_.raiden, smoketest_config, debug=debug)
if error is not None:
append_report('Smoketest assertion error', error)
else:
success = True
finally:
app_.stop()
ethereum.send_signal(2)
err, out = ethereum.communicate()
append_report('Ethereum init stdout',
ethereum_config['init_log_out'].decode('utf-8'))
append_report('Ethereum init stderr',
ethereum_config['init_log_err'].decode('utf-8'))
append_report('Ethereum stdout', out)
append_report('Ethereum stderr', err)
append_report('Smoketest configuration',
json.dumps(smoketest_config))
if success:
print_step(
f'Smoketest successful, report was written to {report_file}')
else:
print_step(
f'Smoketest had errors, report was written to {report_file}',
error=True)
return success
if args['transport'] == 'udp':
with SocketFactory('127.0.0.1', port,
strategy='none') as mapped_socket:
args['mapped_socket'] = mapped_socket
success = _run_smoketest()
elif args['transport'] == 'matrix' and local_matrix.lower() != 'none':
args['mapped_socket'] = None
print_step('Starting Matrix transport')
try:
with HTTPExecutor(
local_matrix,
status=r'^[24]\d\d$',
url=urljoin(args['matrix_server'],
'/_matrix/client/versions'),
shell=True,
):
args['extra_config'] = {
'matrix': {
'discovery_room': {
'server': 'matrix.local.raiden'
},
'server_name': 'matrix.local.raiden',
},
}
success = _run_smoketest()
except (PermissionError, ProcessExitedWithError):
append_report('Matrix server start exception',
traceback.format_exc())
print_step(
f'Error during smoketest setup, report was written to {report_file}',
error=True,
)
success = False
elif args['transport'] == 'matrix' and local_matrix.lower() == "none":
args['mapped_socket'] = None
success = _run_smoketest()
else:
# Shouldn't happen
raise RuntimeError(f"Invalid transport type '{args['transport']}'")
if not success:
sys.exit(1)
def token_network_registry_proxy(deploy_client, token_network_registry_contract):
return TokenNetworkRegistry(
deploy_client,
to_canonical_address(token_network_registry_contract.contract.address),
)
def smoketest(ctx, debug, local_matrix, **kwargs): # pylint: disable=unused-argument
""" Test, that the raiden installation is sane. """
import binascii
from web3 import Web3, HTTPProvider
from web3.middleware import geth_poa_middleware
from raiden.api.python import RaidenAPI
from raiden.tests.utils.geth import geth_wait_and_check
from raiden.tests.integration.contracts.fixtures.contracts import deploy_token
from raiden.tests.utils.smoketest import (
TEST_PARTNER_ADDRESS,
TEST_DEPOSIT_AMOUNT,
deploy_smoketest_contracts,
get_private_key,
load_smoketest_config,
start_ethereum,
run_smoketests,
)
report_file = tempfile.mktemp(suffix='.log')
configure_logging({'': 'DEBUG'}, log_file=report_file)
def append_report(subject, data):
with open(report_file, 'a', encoding='UTF-8') as handler:
handler.write(f'{f" {subject.upper()} ":=^80}{os.linesep}')
if data is not None:
if isinstance(data, bytes):
data = data.decode()
handler.writelines([data + os.linesep])
append_report('Raiden version', json.dumps(get_system_spec()))
append_report('Raiden log', None)
step_count = 7
if ctx.parent.params['transport'] == 'matrix':
step_count = 8
step = 0
def print_step(description, error=False):
nonlocal step
step += 1
click.echo(
'{} {}'.format(
click.style(f'[{step}/{step_count}]', fg='blue'),
click.style(description, fg='green' if not error else 'red'),
),
)
print_step('Getting smoketest configuration')
smoketest_config = load_smoketest_config()
if not smoketest_config:
append_report(
'Smoketest configuration',
'Could not load the smoketest genesis configuration file.',
)
print_step('Starting Ethereum node')
ethereum, ethereum_config = start_ethereum(smoketest_config['genesis'])
port = ethereum_config['rpc']
web3_client = Web3(HTTPProvider(f'http://0.0.0.0:{port}'))
web3_client.middleware_stack.inject(geth_poa_middleware, layer=0)
random_marker = binascii.hexlify(b'raiden').decode()
privatekeys = []
geth_wait_and_check(web3_client, privatekeys, random_marker)
print_step('Deploying Raiden contracts')
host = '0.0.0.0'
client = JSONRPCClient(
host,
ethereum_config['rpc'],
get_private_key(),
web3=web3_client,
)
contract_addresses = deploy_smoketest_contracts(client, 627)
token_contract = deploy_token(client)
token = token_contract(1000, 0, 'TKN', 'TKN')
registry = TokenNetworkRegistry(client, contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY])
registry.add_token(to_canonical_address(token.contract.address))
print_step('Setting up Raiden')
# setup cli arguments for starting raiden
args = dict(
discovery_contract_address=to_checksum_address(
contract_addresses[CONTRACT_ENDPOINT_REGISTRY],
),
registry_contract_address=to_checksum_address(
contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY],
),
secret_registry_contract_address=to_checksum_address(
contract_addresses[CONTRACT_SECRET_REGISTRY],
),
eth_rpc_endpoint='http://127.0.0.1:{}'.format(port),
keystore_path=ethereum_config['keystore'],
address=ethereum_config['address'],
network_id='627',
transport=ctx.parent.params['transport'],
matrix_server='http://localhost:8008'
if ctx.parent.params['matrix_server'] == 'auto'
else ctx.parent.params['matrix_server'],
)
smoketest_config['transport'] = args['transport']
for option_ in app.params:
if option_.name in args.keys():
args[option_.name] = option_.process_value(ctx, args[option_.name])
else:
args[option_.name] = option_.default
password_file = os.path.join(args['keystore_path'], 'password')
with open(password_file, 'w') as handler:
handler.write('password')
port = next(get_free_port('127.0.0.1', 5001))
args['password_file'] = click.File()(password_file)
args['datadir'] = args['keystore_path']
args['api_address'] = 'localhost:' + str(port)
args['sync_check'] = False
def _run_smoketest():
print_step('Starting Raiden')
# invoke the raiden app
app_ = ctx.invoke(app, **args)
raiden_api = RaidenAPI(app_.raiden)
rest_api = RestAPI(raiden_api)
api_server = APIServer(rest_api)
(api_host, api_port) = split_endpoint(args['api_address'])
api_server.start(api_host, api_port)
raiden_api.channel_open(
contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY],
to_canonical_address(token.contract.address),
to_canonical_address(TEST_PARTNER_ADDRESS),
None,
None,
)
raiden_api.set_total_channel_deposit(
contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY],
to_canonical_address(token.contract.address),
to_canonical_address(TEST_PARTNER_ADDRESS),
TEST_DEPOSIT_AMOUNT,
)
smoketest_config['contracts']['registry_address'] = to_checksum_address(
contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY],
)
smoketest_config['contracts']['secret_registry_address'] = to_checksum_address(
contract_addresses[CONTRACT_SECRET_REGISTRY],
)
smoketest_config['contracts']['discovery_address'] = to_checksum_address(
contract_addresses[CONTRACT_ENDPOINT_REGISTRY],
)
smoketest_config['contracts']['token_address'] = to_checksum_address(
token.contract.address,
)
success = False
try:
print_step('Running smoketest')
error = run_smoketests(app_.raiden, smoketest_config, debug=debug)
if error is not None:
append_report('Smoketest assertion error', error)
else:
success = True
finally:
app_.stop()
ethereum.send_signal(2)
err, out = ethereum.communicate()
append_report('Ethereum init stdout', ethereum_config['init_log_out'].decode('utf-8'))
append_report('Ethereum init stderr', ethereum_config['init_log_err'].decode('utf-8'))
append_report('Ethereum stdout', out)
append_report('Ethereum stderr', err)
append_report('Smoketest configuration', json.dumps(smoketest_config))
if success:
print_step(f'Smoketest successful, report was written to {report_file}')
else:
print_step(f'Smoketest had errors, report was written to {report_file}', error=True)
return success
if args['transport'] == 'udp':
with SocketFactory('127.0.0.1', port, strategy='none') as mapped_socket:
args['mapped_socket'] = mapped_socket
success = _run_smoketest()
elif args['transport'] == 'matrix' and local_matrix.lower() != 'none':
args['mapped_socket'] = None
print_step('Starting Matrix transport')
try:
with HTTPExecutor(
local_matrix,
status=r'^[24]\d\d$',
url=urljoin(args['matrix_server'], '/_matrix/client/versions'),
shell=True,
):
args['extra_config'] = {
'matrix': {
'discovery_room': {'server': 'matrix.local.raiden'},
'server_name': 'matrix.local.raiden',
},
}
success = _run_smoketest()
except (PermissionError, ProcessExitedWithError):
append_report('Matrix server start exception', traceback.format_exc())
print_step(
f'Error during smoketest setup, report was written to {report_file}',
error=True,
)
success = False
elif args['transport'] == 'matrix' and local_matrix.lower() == "none":
args['mapped_socket'] = None
success = _run_smoketest()
else:
# Shouldn't happen
raise RuntimeError(f"Invalid transport type '{args['transport']}'")
if not success:
sys.exit(1)
def __init__(
self,
config: typing.Dict,
chain: BlockChainService,
query_start_block: typing.BlockNumber,
default_registry: TokenNetworkRegistry,
default_secret_registry: SecretRegistry,
transport,
raiden_event_handler,
message_handler,
discovery: Discovery = None,
):
raiden = RaidenService(
chain=chain,
query_start_block=query_start_block,
default_registry=default_registry,
default_secret_registry=default_secret_registry,
private_key_bin=decode_hex(config['privatekey_hex']),
transport=transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
config=config,
discovery=discovery,
)
# Check if files with older versions of the DB exist, emit a warning
db_base_path = os.path.dirname(config['database_path'])
old_version_path = older_db_file(db_base_path)
if old_version_path:
old_version_file = os.path.basename(old_version_path)
raise RuntimeError(
f'A database file for a previous version of Raiden exists '
f'{old_version_path}. Because the new version of Raiden '
f'introduces changes which break compatibility with the old '
f'database, a new database is necessary. The new database '
f'file will be created automatically for you, but as a side effect all '
f'previous data will be unavailable. The only way to proceed '
f'without the risk of losing funds is to leave all token networks '
f'and *make a backup* of the existing database. Please, *after* all the '
f'existing channels have been settled, make sure to make a backup by '
f'renaming {old_version_file} to {old_version_file}_backup. Then the new '
f'version of Raiden can be used.', )
# check that the settlement timeout fits the limits of the contract
invalid_settle_timeout = (
config['settle_timeout'] <
default_registry.settlement_timeout_min()
or config['settle_timeout'] >
default_registry.settlement_timeout_max()
or config['settle_timeout'] < config['reveal_timeout'] * 2)
if invalid_settle_timeout:
raise InvalidSettleTimeout(
('Settlement timeout for Registry contract {} must '
'be in range [{}, {}], is {}').format(
to_checksum_address(default_registry.address),
default_registry.settlement_timeout_min(),
default_registry.settlement_timeout_max(),
config['settle_timeout'],
), )
self.config = config
self.discovery = discovery
self.raiden = raiden
self.start_console = self.config['console']
# raiden.ui.console:Console assumes that a services
# attribute is available for auto-registration
self.services = dict()
def __init__(
self,
config: typing.Dict,
chain: BlockChainService,
query_start_block: typing.BlockNumber,
default_registry: TokenNetworkRegistry,
default_secret_registry: SecretRegistry,
transport,
raiden_event_handler,
message_handler,
discovery: Discovery = None,
):
raiden = RaidenService(
chain=chain,
query_start_block=query_start_block,
default_registry=default_registry,
default_secret_registry=default_secret_registry,
private_key_bin=decode_hex(config['privatekey_hex']),
transport=transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
config=config,
discovery=discovery,
)
# Check if files with older versions of the DB exist, emit a warning
db_base_path = os.path.dirname(config['database_path'])
old_version_path = older_db_file(db_base_path)
if old_version_path:
old_version_file = os.path.basename(old_version_path)
raise RuntimeError(
f'A database file for a previous version of Raiden exists '
f'{old_version_path}. Because the new version of Raiden '
f'introduces changes which break compatibility with the old '
f'database, a new database is necessary. The new database '
f'file will be created automatically for you, but as a side effect all '
f'previous data will be unavailable. The only way to proceed '
f'without the risk of losing funds is to leave all token networks '
f'and *make a backup* of the existing database. Please, *after* all the '
f'existing channels have been settled, make sure to make a backup by '
f'renaming {old_version_file} to {old_version_file}_backup. Then the new '
f'version of Raiden can be used.',
)
# check that the settlement timeout fits the limits of the contract
invalid_settle_timeout = (
config['settle_timeout'] < default_registry.settlement_timeout_min() or
config['settle_timeout'] > default_registry.settlement_timeout_max() or
config['settle_timeout'] < config['reveal_timeout'] * 2
)
if invalid_settle_timeout:
raise InvalidSettleTimeout(
(
'Settlement timeout for Registry contract {} must '
'be in range [{}, {}], is {}'
).format(
to_checksum_address(default_registry.address),
default_registry.settlement_timeout_min(),
default_registry.settlement_timeout_max(),
config['settle_timeout'],
),
)
self.config = config
self.discovery = discovery
self.raiden = raiden
self.start_console = self.config['console']
# raiden.ui.console:Console assumes that a services
# attribute is available for auto-registration
self.services = dict()
