def test_api_compliance(discovery_blockchain, local): contract_discovery_instance, address = discovery_blockchain if local: contract_discovery_instance = Discovery() assert isinstance(contract_discovery_instance, Discovery) else: assert isinstance(contract_discovery_instance, ContractDiscovery) # test that `get` for unknown address raises KeyError with pytest.raises(KeyError): assert contract_discovery_instance.get( ('01' * 20).decode('hex')) is None assert contract_discovery_instance.nodeid_by_host_port( ('127.0.0.1', 44444)) is None # test, that `update_endpoint` and 'classic' `register` do the same contract_discovery_instance.register(address, '127.0.0.1', 44444) not local and gevent.sleep(30) assert contract_discovery_instance.nodeid_by_host_port( ('127.0.0.1', 44444)) == address # test, that `register`ing twice does update do the same contract_discovery_instance.register(address, '127.0.0.1', 88888) not local and gevent.sleep(30) assert contract_discovery_instance.nodeid_by_host_port( ('127.0.0.1', 88888)) == address
def create_apps( blockchain_services, raiden_udp_ports, transport_class, verbosity, send_ping_time, max_unresponsive_time, reveal_timeout): """ Create the apps. Note: The generated network will use two subnets, 127.0.0.10 and 127.0.0.11, for this test to work in a mac both virtual interfaces must be created prior to the test execution:: MacOSX (tested on 10.11.5): interface ip address netmask ifconfig lo0 alias 127.0.0.10 255.255.255.0 ifconfig lo0 alias 127.0.0.11 255.255.255.0 Alternative syntax: ifconfig lo:0 127.0.0.10 ifconfig lo:1 127.0.0.11 """ # pylint: disable=too-many-locals half_of_nodes = len(blockchain_services) // 2 discovery = Discovery() apps = [] for idx, blockchain in enumerate(blockchain_services): port = raiden_udp_ports[idx] private_key = blockchain.private_key nodeid = privatekey_to_address(private_key) if verbosity > 7: blockchain.set_verbosity(1) # split the nodes into two different networks if idx > half_of_nodes: # TODO: check if the loopback interfaces exists host = '127.0.0.11' else: host = '127.0.0.10' discovery.register(nodeid, host, port) app = create_app( private_key, blockchain, discovery, transport_class, send_ping_time, max_unresponsive_time, port=port, host=host, reveal_timeout=reveal_timeout ) apps.append(app) return apps
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 create_apps( blockchain_services, transport_class, verbosity, send_ping_time, max_unresponsive_time): """ Create the apps. Note: The generated network will use two subnets, 127.0.0.10 and 127.0.0.11, for this test to work in a mac both virtual interfaces must be created prior to the test execution:: ifconfig lo:0 127.0.0.10 ifconfig lo:1 127.0.0.11 """ # pylint: disable=too-many-locals half_of_nodes = len(blockchain_services) // 2 discovery = Discovery() apps = [] for idx, blockchain in enumerate(blockchain_services): port = INITIAL_PORT + idx private_key = blockchain.private_key nodeid = privatekey_to_address(private_key) if verbosity > 7: blockchain.set_verbosity(1) # split the nodes into two different networks if idx > half_of_nodes: # TODO: check if the loopback interfaces exists host = '127.0.0.11' else: host = '127.0.0.10' discovery.register(nodeid, host, port) app = create_app( private_key, blockchain, discovery, transport_class, send_ping_time, max_unresponsive_time, port=port, host=host ) apps.append(app) return apps
def test_mock_registry_api_compliance(): address = make_address() contract_discovery_instance = Discovery() # `get` for unknown address raises with pytest.raises(InvalidAddress): contract_discovery_instance.get(address) # `update_endpoint` and 'classic' `register` do the same contract_discovery_instance.register(address, "127.0.0.1", 44444) assert contract_discovery_instance.get(address) == ("127.0.0.1", 44444) # `register`ing twice does update do the same contract_discovery_instance.register(address, "127.0.0.1", 88888) assert contract_discovery_instance.get(address) == ("127.0.0.1", 88888)
def api_raiden_service(monkeypatch, api_test_server, api_test_context, blockchain_services, transport_class, max_unresponsive_time, send_ping_time, reveal_timeout, raiden_udp_ports): blockchain = blockchain_services[0] config = copy.deepcopy(App.default_config) config['port'] = raiden_udp_ports[0] config['host'] = '127.0.0.1' config['privatekey_hex'] = blockchain.private_key.encode('hex') config['send_ping_time'] = send_ping_time config['max_unresponsive_time'] = max_unresponsive_time config['reveal_timeout'] = reveal_timeout raiden_service = RaidenService(blockchain, blockchain.private_key, transport_class, Discovery(), config) monkeypatch.setattr(raiden_service.api, 'get_channel_list', api_test_context.query_channels) monkeypatch.setattr(raiden_service.api, 'get_tokens_list', api_test_context.query_tokens) monkeypatch.setattr(raiden_service.api, 'open', api_test_context.open_channel) monkeypatch.setattr(raiden_service.api, 'deposit', api_test_context.deposit) monkeypatch.setattr(raiden_service.api, 'close', api_test_context.close) monkeypatch.setattr(raiden_service.api, 'settle', api_test_context.settle) monkeypatch.setattr(raiden_service.api, 'get_channel', api_test_context.get_channel) # also make sure that the test server's raiden_api uses this mock # raiden service monkeypatch.setattr(api_test_server, 'raiden_api', raiden_service.api) return raiden_service
def test_mock_registry_api_compliance(): address = make_address() contract_discovery_instance = Discovery() # `get` for unknown address raises with pytest.raises(InvalidAddress): contract_discovery_instance.get(address) # `update_endpoint` and 'classic' `register` do the same contract_discovery_instance.register(address, '127.0.0.1', 44444) assert contract_discovery_instance.get(address) == ('127.0.0.1', 44444) # `register`ing twice does update do the same contract_discovery_instance.register(address, '127.0.0.1', 88888) assert contract_discovery_instance.get(address) == ('127.0.0.1', 88888)
def api_raiden_service(monkeypatch, api_backend, api_test_context, blockchain_services, transport_class, reveal_timeout, raiden_udp_ports, tmpdir): blockchain = blockchain_services[0] config = copy.deepcopy(App.DEFAULT_CONFIG) config['port'] = raiden_udp_ports[0] config['host'] = '127.0.0.1' config['external_ip'] = '127.0.0.1' config['external_port'] = raiden_udp_ports[0] config['privatekey_hex'] = blockchain.private_key.encode('hex') config['reveal_timeout'] = reveal_timeout config['database_path'] = os.path.join(tmpdir.strpath, 'database.db') raiden_service = RaidenService( blockchain, blockchain.private_key, transport_class(config['host'], config['port']), Discovery(), config) api = RaidenAPI(raiden_service) monkeypatch.setattr(api, 'get_channel_list', api_test_context.query_channels) monkeypatch.setattr(api, 'get_tokens_list', api_test_context.query_tokens) monkeypatch.setattr(api, 'open', api_test_context.open_channel) monkeypatch.setattr(api, 'deposit', api_test_context.deposit) monkeypatch.setattr(api, 'close', api_test_context.close) monkeypatch.setattr(api, 'settle', api_test_context.settle) monkeypatch.setattr(api, 'get_channel', api_test_context.get_channel) monkeypatch.setattr(api, 'get_network_events', api_test_context.get_network_events) monkeypatch.setattr(api, 'get_token_network_events', api_test_context.get_token_network_events) monkeypatch.setattr(api, 'get_channel_events', api_test_context.get_channel_events) monkeypatch.setattr(api, 'transfer', api_test_context.transfer) monkeypatch.setattr(api, 'token_swap', api_test_context.token_swap) monkeypatch.setattr(api, 'expect_token_swap', api_test_context.expect_token_swap) monkeypatch.setattr(api, 'connect_token_network', api_test_context.connect) monkeypatch.setattr(api, 'leave_token_network', api_test_context.leave) monkeypatch.setattr(api, 'get_connection_manager_funds', api_test_context.get_connection_manager_funds) monkeypatch.setattr(api, 'get_connection_managers_list', api_test_context.get_connection_managers_list) monkeypatch.setattr(api, 'register_token', api_test_context.register_token) monkeypatch.setattr(api, 'manager_address_if_token_registered', api_test_context.manager_address_if_token_registered) # also make sure that the test server's raiden_api uses this mock # raiden service _, raiden_api = api_backend monkeypatch.setattr(raiden_api, 'raiden_api', api) return raiden_service
def api_raiden_service( monkeypatch, api_backend, api_test_context, blockchain_services, transport_class, max_unresponsive_time, send_ping_time, reveal_timeout, raiden_udp_ports, tmpdir): blockchain = blockchain_services[0] config = copy.deepcopy(App.default_config) config['port'] = raiden_udp_ports[0] config['host'] = '127.0.0.1' config['privatekey_hex'] = blockchain.private_key.encode('hex') config['send_ping_time'] = send_ping_time config['max_unresponsive_time'] = max_unresponsive_time config['reveal_timeout'] = reveal_timeout config['database_path'] = os.path.join(tmpdir.strpath, 'database.db') raiden_service = RaidenService( blockchain, blockchain.private_key, transport_class, Discovery(), config ) api = RaidenAPI(raiden_service) monkeypatch.setattr(api, 'get_channel_list', api_test_context.query_channels) monkeypatch.setattr(api, 'get_tokens_list', api_test_context.query_tokens) monkeypatch.setattr(api, 'open', api_test_context.open_channel) monkeypatch.setattr(api, 'deposit', api_test_context.deposit) monkeypatch.setattr(api, 'close', api_test_context.close) monkeypatch.setattr(api, 'settle', api_test_context.settle) monkeypatch.setattr(api, 'get_channel', api_test_context.get_channel) monkeypatch.setattr(api, 'get_network_events', api_test_context.get_network_events) monkeypatch.setattr(api, 'get_token_network_events', api_test_context.get_token_network_events) monkeypatch.setattr(api, 'get_channel_events', api_test_context.get_channel_events) monkeypatch.setattr(api, 'transfer', api_test_context.transfer) monkeypatch.setattr(api, 'token_swap', api_test_context.token_swap) monkeypatch.setattr(api, 'expect_token_swap', api_test_context.expect_token_swap) # also make sure that the test server's raiden_api uses this mock # raiden service _, raiden_api = api_backend monkeypatch.setattr(raiden_api, 'raiden_api', api) return raiden_service
def profile_transfer(num_nodes=10, channels_per_node=2): num_tokens = 1 deposit = 10000 tokens = [ sha3('token:{}'.format(number))[:20] for number in range(num_tokens) ] private_keys = [ sha3('speed:{}'.format(position)) for position in range(num_nodes) ] blockchain_services = list() tester = tester_state( private_keys[0], private_keys, tester_blockgas_limit(), ) nettingchannel_library_address = tester_nettingchannel_library_address( tester_state, ) channelmanager_library_address = tester_channelmanager_library_address( tester_state, nettingchannel_library_address, ) registry_address = tester_registry_address( tester_state, channelmanager_library_address, ) for privkey in private_keys: blockchain = BlockChainServiceTesterMock( privkey, tester, registry_address, ) blockchain_services.append(blockchain) registry = blockchain_services[0].registry(registry_address) for token in tokens: registry.add_token(token) discovery_mock = Discovery() endpoint_discovery_services = [discovery_mock for _ in private_keys] verbosity = 3 apps = create_apps( blockchain_services, endpoint_discovery_services, tokens, channels_per_node, deposit, DEFAULT_SETTLE_TIMEOUT, UDPTransport, verbosity, ) main_app = apps[0] # channels main_graph = main_app.raiden.token_to_channelgraph[tokens[0]] # search for a path of length=2 A > B > C num_hops = 2 source = main_app.raiden.address paths = main_graph.get_paths_of_length(source, num_hops) # sanity check assert paths path = paths[0] target = path[-1] # addresses token_address = main_graph.token_address amount = 10 # measure the hot path with profiling.profile(): result = main_app.raiden.mediated_transfer_async( token_address, amount, target, 1, ) result.wait() profiling.print_all_threads()
def create_sequential_network(private_keys, asset_address, registry_address, # pylint: disable=too-many-arguments channels_per_node, deposit, settle_timeout, poll_timeout, transport_class, blockchain_service_class): """ Create a fully connected network with `num_nodes`, the nodes are connect sequentially. Returns: A list of apps of size `num_nodes`, with the property that every sequential pair in the list has an open channel with `deposit` for each participant. """ # pylint: disable=too-many-locals random.seed(42) host = '127.0.0.1' num_nodes = len(private_keys) if num_nodes < 2: raise ValueError('cannot create a network with less than two nodes') if channels_per_node not in (0, 1, 2, CHAIN): raise ValueError('can only create networks with 0, 1, 2 or CHAIN channels') discovery = Discovery() blockchain_service_class = blockchain_service_class or BlockChainServiceMock apps = [] for idx, privatekey_bin in enumerate(private_keys): port = INITIAL_PORT + idx nodeid = privtoaddr(privatekey_bin) discovery.register(nodeid, host, port) jsonrpc_client = JSONRPCClient( privkey=privatekey_bin, print_communication=False, ) blockchain_service = blockchain_service_class( jsonrpc_client, registry_address, poll_timeout=poll_timeout, ) app = create_app( privatekey_bin, blockchain_service, discovery, transport_class, port=port, host=host, ) apps.append(app) if channels_per_node == 0: app_channels = list() if channels_per_node == 1: every_two = iter(apps) app_channels = list(zip(every_two, every_two)) if channels_per_node == 2: app_channels = list(zip(apps, apps[1:] + [apps[0]])) if channels_per_node == CHAIN: app_channels = list(zip(apps[:-1], apps[1:])) setup_channels( asset_address, app_channels, deposit, settle_timeout, ) for app in apps: app.raiden.register_registry(app.raiden.chain.default_registry) return apps
def create_network(private_keys, assets_addresses, registry_address, # pylint: disable=too-many-arguments channels_per_node, deposit, settle_timeout, poll_timeout, transport_class, blockchain_service_class): """ Initialize a local test network using the UDP protocol. Note: The generated network will use two subnets, 127.0.0.10 and 127.0.0.11, for this test to work both virtual interfaces must be created prior to the test execution:: ifconfig lo:0 127.0.0.10 ifconfig lo:1 127.0.0.11 """ # pylint: disable=too-many-locals random.seed(1337) num_nodes = len(private_keys) if channels_per_node is not CHAIN and channels_per_node > num_nodes: raise ValueError("Can't create more channels than nodes") # if num_nodes it is not even half_of_nodes = int(floor(len(private_keys) / 2)) # globals discovery = Discovery() # The mock needs to be atomic since all app's will use the same instance, # for the real application the syncronization is done by the JSON-RPC # server blockchain_service_class = blockchain_service_class or BlockChainServiceMock # Each app instance is a Node in the network apps = [] for idx, privatekey_bin in enumerate(private_keys): # TODO: check if the loopback interfaces exists # split the nodes into two different networks if idx > half_of_nodes: host = '127.0.0.11' else: host = '127.0.0.10' nodeid = privtoaddr(privatekey_bin) port = INITIAL_PORT + idx discovery.register(nodeid, host, port) jsonrpc_client = JSONRPCClient( privkey=privatekey_bin, print_communication=False, ) blockchain_service = blockchain_service_class( jsonrpc_client, registry_address, poll_timeout=poll_timeout, ) app = create_app( privatekey_bin, blockchain_service, discovery, transport_class, port=port, host=host, ) apps.append(app) for asset in assets_addresses: if channels_per_node == CHAIN: app_channels = list(zip(apps[:-1], apps[1:])) else: app_channels = list(network_with_minimum_channels(apps, channels_per_node)) setup_channels( asset, app_channels, deposit, settle_timeout, ) for app in apps: app.raiden.register_registry(app.raiden.chain.default_registry) return apps
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 create_apps( blockchain_services, raiden_udp_ports, transport_class, verbosity, 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. Note: The generated network will use two subnets, 127.0.0.10 and 127.0.0.11, for this test to work in a mac both virtual interfaces must be created prior to the test execution:: MacOSX (tested on 10.11.5): interface ip address netmask ifconfig lo0 alias 127.0.0.10 255.255.255.0 ifconfig lo0 alias 127.0.0.11 255.255.255.0 Alternative syntax: ifconfig lo:0 127.0.0.10 ifconfig lo:1 127.0.0.11 """ # pylint: disable=too-many-locals half_of_nodes = len(blockchain_services) // 2 discovery = Discovery() apps = [] for idx, blockchain in enumerate(blockchain_services): port = raiden_udp_ports[idx] private_key = blockchain.private_key nodeid = privatekey_to_address(private_key) if verbosity > 7: blockchain.set_verbosity(1) # split the nodes into two different networks if idx > half_of_nodes: # TODO: check if the loopback interfaces exists host = '127.0.0.11' else: host = '127.0.0.10' discovery.register(nodeid, host, port) config = { 'host': host, 'port': port, 'privatekey_hex': private_key.encode('hex'), '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) app = App( copy, blockchain, discovery, transport_class, ) app.raiden.protocol.transport.throttle_policy = DummyPolicy() apps.append(app) return apps
def test_api_compliance(discovery_blockchain, local): contract_discovery_instance, address = discovery_blockchain if local: contract_discovery_instance = Discovery() assert isinstance(contract_discovery_instance, Discovery) else: assert isinstance(contract_discovery_instance, ContractDiscovery) # test that `get` for unknown address raises KeyError with pytest.raises(KeyError): assert contract_discovery_instance.get(('01' * 20).decode('hex')) is None assert contract_discovery_instance.nodeid_by_host_port(('127.0.0.1', 44444)) is None # test, that `update_endpoint` and 'classic' `register` do the same contract_discovery_instance.register(address, '127.0.0.1', 44444) not local and gevent.sleep(30) assert contract_discovery_instance.nodeid_by_host_port(('127.0.0.1', 44444)) == address assert contract_discovery_instance.get(address) == ('127.0.0.1', 44444) # test, that `register`ing twice does update do the same contract_discovery_instance.register(address, '127.0.0.1', 88888) not local and gevent.sleep(30) assert contract_discovery_instance.nodeid_by_host_port(('127.0.0.1', 88888)) == address assert contract_discovery_instance.get(address) == ('127.0.0.1', 88888)
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 main(): import argparse parser = argparse.ArgumentParser() parser.add_argument('rpc_server', help='The host:port of the json-rpc server') parser.add_argument('registry_address', help='The asset registry contract address') parser.add_argument('config_file', help='Configuration file for the raiden note') parser.add_argument( '-h', '--host', default='0.0.0.0', help='Local address that the raiden app will bind to', ) parser.add_argument( '-p', '--port', default=INITIAL_PORT, help='Local port that the raiden app will bind to', ) args = parser.parse_args() rpc_connection = args.rpc_server.split(':') rpc_connection = (rpc_connection[0], int(rpc_connection[1])) config_file = args.config_file host = args.host port = args.port with codecs.open(config_file, encoding='utf8') as handler: config = yaml.load(handler) config['host'] = host config['port'] = port if 'privkey' not in config: print('Missing "privkey" in the configuration file, cannot proceed') sys.exit(1) blockchain_server = BlockChainService( rpc_connection, config['privkey'], privtoaddr(config['privkey']), args.registry_address, ) discovery = Discovery() for node in config['nodes']: discovery.register(node['nodeid'], node['host'], node['port']) app = App(config, blockchain_server, discovery) for asset_address in blockchain_server.asset_addresses: app.raiden.setup_asset(asset_address, app.config['reveal_timeout']) # TODO: # - Ask for confirmation to quit if there are any locked transfers that did # not timeout. # 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 create_sequential_network(blockchain_services, asset_address, channels_per_node, deposit, settle_timeout, transport_class, verbosity): """ Create a fully connected network with `num_nodes`, the nodes are connect sequentially. Returns: A list of apps of size `num_nodes`, with the property that every sequential pair in the list has an open channel with `deposit` for each participant. """ # pylint: disable=too-many-locals host = '127.0.0.1' num_nodes = len(blockchain_services) if num_nodes < 2: raise ValueError('cannot create a network with less than two nodes') if channels_per_node not in (0, 1, 2, CHAIN): raise ValueError( 'can only create networks with 0, 1, 2 or CHAIN channels') discovery = Discovery() apps = [] for idx, blockchain in enumerate(blockchain_services): port = INITIAL_PORT + idx private_key = blockchain.private_key nodeid = privatekey_to_address(private_key) discovery.register(nodeid, host, port) if verbosity > 7: blockchain.set_verbose() app = create_app( private_key, blockchain, discovery, transport_class, port=port, host=host, ) apps.append(app) if channels_per_node == 0: app_channels = list() if channels_per_node == 1: every_two = iter(apps) app_channels = list(zip(every_two, every_two)) if channels_per_node == 2: app_channels = list(zip(apps, apps[1:] + [apps[0]])) if channels_per_node == CHAIN: app_channels = list(zip(apps[:-1], apps[1:])) setup_channels( asset_address, app_channels, deposit, settle_timeout, ) for app in apps: app.raiden.register_registry(app.raiden.chain.default_registry) return apps
def test_mock_registry_api_compliance(): address = make_address() contract_discovery_instance = Discovery() # `get` for unknown address raises with pytest.raises(KeyError): contract_discovery_instance.get(address) assert contract_discovery_instance.nodeid_by_host_port( ('127.0.0.1', 44444)) is None # `update_endpoint` and 'classic' `register` do the same contract_discovery_instance.register(address, '127.0.0.1', 44444) assert contract_discovery_instance.nodeid_by_host_port( ('127.0.0.1', 44444)) == address assert contract_discovery_instance.get(address) == ('127.0.0.1', 44444) # `register`ing twice does update do the same contract_discovery_instance.register(address, '127.0.0.1', 88888) assert contract_discovery_instance.nodeid_by_host_port( ('127.0.0.1', 88888)) == address assert contract_discovery_instance.get(address) == ('127.0.0.1', 88888)
def create_network( private_keys, assets_addresses, registry_address, # pylint: disable=too-many-arguments channels_per_node, deposit, settle_timeout, poll_timeout, transport_class, blockchain_service_class): """ Initialize a local test network using the UDP protocol. Note: The generated network will use two subnets, 127.0.0.10 and 127.0.0.11, for this test to work both virtual interfaces must be created prior to the test execution:: ifconfig lo:0 127.0.0.10 ifconfig lo:1 127.0.0.11 """ # pylint: disable=too-many-locals random.seed(1337) num_nodes = len(private_keys) if channels_per_node is not CHAIN and channels_per_node > num_nodes: raise ValueError("Can't create more channels than nodes") # if num_nodes it is not even half_of_nodes = int(floor(len(private_keys) / 2)) # globals discovery = Discovery() # The mock needs to be atomic since all app's will use the same instance, # for the real application the syncronization is done by the JSON-RPC # server blockchain_service_class = blockchain_service_class or BlockChainServiceMock # Each app instance is a Node in the network apps = [] for idx, privatekey_bin in enumerate(private_keys): # TODO: check if the loopback interfaces exists # split the nodes into two different networks if idx > half_of_nodes: host = '127.0.0.11' else: host = '127.0.0.10' nodeid = privtoaddr(privatekey_bin) port = INITIAL_PORT + idx discovery.register(nodeid, host, port) jsonrpc_client = JSONRPCClient( privkey=privatekey_bin, print_communication=False, ) blockchain_service = blockchain_service_class( jsonrpc_client, registry_address, poll_timeout=poll_timeout, ) app = create_app( privatekey_bin, blockchain_service, discovery, transport_class, port=port, host=host, ) apps.append(app) for asset in assets_addresses: if channels_per_node == CHAIN: app_channels = list(zip(apps[:-1], apps[1:])) else: app_channels = list( network_with_minimum_channels(apps, channels_per_node)) setup_channels( asset, app_channels, deposit, settle_timeout, ) for app in apps: app.raiden.register_registry(app.raiden.chain.default_registry) return apps
def main(): import argparse parser = argparse.ArgumentParser() parser.add_argument('rpc_server', help='The host:port of the json-rpc server') parser.add_argument('registry_address', help='The asset registry contract address') parser.add_argument('config_file', help='Configuration file for the raiden note') parser.add_argument( '-h', '--host', default='0.0.0.0', help='Local address that the raiden app will bind to', ) parser.add_argument( '-p', '--port', default=INITIAL_PORT, help='Local port that the raiden app will bind to', ) args = parser.parse_args() rpc_connection = args.rpc_server.split(':') rpc_connection = (rpc_connection[0], int(rpc_connection[1])) config_file = args.config_file host = args.host port = args.port with codecs.open(config_file, encoding='utf8') as handler: config = yaml.load(handler) config['host'] = host config['port'] = port if 'privkey' not in config: print('Missing "privkey" in the configuration file, cannot proceed') sys.exit(1) blockchain_server = BlockChainService(rpc_connection, args.registry_address) discovery = Discovery() for node in config['nodes']: discovery.register(node['nodeid'], node['host'], node['port']) app = App(config, blockchain_server, discovery) for asset_address in blockchain_server.asset_addresses: app.raiden.setup_asset(asset_address, app.config['min_locktime']) # TODO: # - Ask for confirmation to quit if there are any locked transfers that did # not timeout. # 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 create_sequential_network( private_keys, asset_address, registry_address, # pylint: disable=too-many-arguments channels_per_node, deposit, settle_timeout, poll_timeout, transport_class, blockchain_service_class): """ Create a fully connected network with `num_nodes`, the nodes are connect sequentially. Returns: A list of apps of size `num_nodes`, with the property that every sequential pair in the list has an open channel with `deposit` for each participant. """ # pylint: disable=too-many-locals random.seed(42) host = '127.0.0.1' num_nodes = len(private_keys) if num_nodes < 2: raise ValueError('cannot create a network with less than two nodes') if channels_per_node not in (0, 1, 2, CHAIN): raise ValueError( 'can only create networks with 0, 1, 2 or CHAIN channels') discovery = Discovery() blockchain_service_class = blockchain_service_class or BlockChainServiceMock apps = [] for idx, privatekey_bin in enumerate(private_keys): port = INITIAL_PORT + idx nodeid = privtoaddr(privatekey_bin) discovery.register(nodeid, host, port) jsonrpc_client = JSONRPCClient( privkey=privatekey_bin, print_communication=False, ) blockchain_service = blockchain_service_class( jsonrpc_client, registry_address, poll_timeout=poll_timeout, ) app = create_app( privatekey_bin, blockchain_service, discovery, transport_class, port=port, host=host, ) apps.append(app) if channels_per_node == 0: app_channels = list() if channels_per_node == 1: every_two = iter(apps) app_channels = list(zip(every_two, every_two)) if channels_per_node == 2: app_channels = list(zip(apps, apps[1:] + [apps[0]])) if channels_per_node == CHAIN: app_channels = list(zip(apps[:-1], apps[1:])) setup_channels( asset_address, app_channels, deposit, settle_timeout, ) for app in apps: app.raiden.register_registry(app.raiden.chain.default_registry) return apps
def test_mock_registry_api_compliance(): address = make_address() contract_discovery_instance = Discovery() # `get` for unknown address raises with pytest.raises(KeyError): contract_discovery_instance.get(address) assert contract_discovery_instance.nodeid_by_host_port(('127.0.0.1', 44444)) is None # `update_endpoint` and 'classic' `register` do the same contract_discovery_instance.register(address, '127.0.0.1', 44444) assert contract_discovery_instance.nodeid_by_host_port(('127.0.0.1', 44444)) == address assert contract_discovery_instance.get(address) == ('127.0.0.1', 44444) # `register`ing twice does update do the same contract_discovery_instance.register(address, '127.0.0.1', 88888) assert contract_discovery_instance.nodeid_by_host_port(('127.0.0.1', 88888)) == address assert contract_discovery_instance.get(address) == ('127.0.0.1', 88888)
def create_network(blockchain_services, assets_addresses, channels_per_node, deposit, settle_timeout, transport_class, verbosity): """ Initialize a raiden test network. Note: The generated network will use two subnets, 127.0.0.10 and 127.0.0.11, for this test to work in a mac both virtual interfaces must be created prior to the test execution:: ifconfig lo:0 127.0.0.10 ifconfig lo:1 127.0.0.11 """ # pylint: disable=too-many-locals num_nodes = len(blockchain_services) if channels_per_node is not CHAIN and channels_per_node > num_nodes: raise ValueError("Can't create more channels than nodes") half_of_nodes = len(blockchain_services) // 2 discovery = Discovery() apps = [] for idx, blockchain in enumerate(blockchain_services): private_key = blockchain.private_key # TODO: check if the loopback interfaces exists # split the nodes into two different networks if idx > half_of_nodes: host = '127.0.0.11' else: host = '127.0.0.10' nodeid = privatekey_to_address(private_key) port = INITIAL_PORT + idx discovery.register(nodeid, host, port) if verbosity > 7: blockchain.set_verbose() app = create_app( private_key, blockchain, discovery, transport_class, port=port, host=host, ) apps.append(app) for asset in assets_addresses: if channels_per_node == CHAIN: app_channels = list(zip(apps[:-1], apps[1:])) else: app_channels = list( network_with_minimum_channels(apps, channels_per_node)) setup_channels( asset, app_channels, deposit, settle_timeout, ) for app in apps: app.raiden.register_registry(app.raiden.chain.default_registry) return apps