def register_channel_manager(self, manager_address):
manager = self.default_registry.manager(manager_address)
netting_channels = [
self.chain.netting_channel(channel_address) for channel_address in
manager.channels_by_participant(self.address)
]
# Install the filters first to avoid missing changes, as a consequence
# some events might be applied twice.
self.blockchain_events.add_channel_manager_listener(manager)
for channel in netting_channels:
self.blockchain_events.add_netting_channel_listener(channel)
token_address = manager.token_address()
edge_list = manager.channels_addresses()
channels_detail = [
self.get_channel_details(token_address, channel)
for channel in netting_channels
]
graph = ChannelGraph(
self.address,
manager_address,
token_address,
edge_list,
channels_detail,
)
self.manager_to_token[manager_address] = token_address
self.token_to_channelgraph[token_address] = graph
self.tokens_to_connectionmanagers[token_address] = ConnectionManager(
self, token_address, graph)
def test_addchannel_must_not_overwrite(): # pylint: disable=too-many-locals
""" Calling add_channel for an existing channel must not overwrite it. """
our_address = make_address()
partner_address = make_address()
channel_manager_address = make_address()
token_address = make_address()
channel_address = make_address()
our_state = ParticipantStateMock(our_address)
partner_state = ParticipantStateMock(partner_address)
netting_channel = NettingChannelMock(channel_address)
external_state = ExternalStateMock(netting_channel)
reveal_timeout = 5
settle_timeout = 10
channel_detail = ChannelDetails(
channel_address,
our_state,
partner_state,
external_state,
reveal_timeout,
settle_timeout,
)
edge_list = []
channel_detail_list = [channel_detail]
graph = ChannelGraph(
our_address,
channel_manager_address,
token_address,
edge_list,
channel_detail_list,
)
first_instance = graph.address_to_channel[channel_address]
graph.add_channel(channel_detail)
assert first_instance is graph.address_to_channel[channel_address]
def register_registry(self, registry_address):
proxies = get_relevant_proxies(
self.chain,
self.address,
registry_address,
)
# Install the filters first to avoid missing changes, as a consequence
# some events might be applied twice.
self.pyethapp_blockchain_events.add_proxies_listeners(proxies)
block_number = self.get_block_number()
for manager in proxies.channel_managers:
token_address = manager.token_address()
manager_address = manager.address
channels_detail = list()
netting_channels = proxies.channelmanager_nettingchannels[manager_address]
for channel in netting_channels:
detail = self.get_channel_details(token_address, channel)
channels_detail.append(detail)
edge_list = manager.channels_addresses()
graph = ChannelGraph(
self.address,
manager_address,
token_address,
edge_list,
channels_detail,
block_number,
)
self.manager_to_token[manager_address] = token_address
self.token_to_channelgraph[token_address] = graph
self.tokens_to_connectionmanagers[token_address] = ConnectionManager(
self,
token_address,
graph
)
self.start_neighbours_healthcheck(graph)
def register_channel_manager(self, channel_manager):
""" Discover and register the channels for the given asset. """
translator = ContractTranslator(CHANNEL_MANAGER_ABI)
# To avoid missing changes, first create the filter, call the
# contract and then start polling.
channelnew = channel_manager.channelnew_filter()
all_netting_contracts = channel_manager.channels_by_participant(
self.address)
self.start_event_listener(
'ChannelManager {}'.format(pex(channel_manager.address)),
channelnew,
translator,
)
asset_address_bin = channel_manager.asset_address()
channel_manager_address_bin = channel_manager.address
edges = channel_manager.channels_addresses()
channel_graph = ChannelGraph(edges)
asset_manager = AssetManager(
self,
asset_address_bin,
channel_manager_address_bin,
channel_graph,
)
self.managers_by_asset_address[asset_address_bin] = asset_manager
self.managers_by_address[channel_manager_address_bin] = asset_manager
for netting_contract_address in all_netting_contracts:
asset_manager.register_channel_by_address(
netting_contract_address,
self.config['reveal_timeout'],
)