def test_request_peers_bidir(registered_mmp_servicer2):
request = mmp.PeerRequest(instance_name='meso[2]')
result = registered_mmp_servicer2.RequestPeers(request, None)
assert result.status == mmp.RESULT_STATUS_SUCCESS
assert result.conduits[0] == mmp.Conduit(sender='macro.out',
receiver='meso.in')
assert result.conduits[1] == mmp.Conduit(sender='meso.out',
receiver='micro.in')
assert result.conduits[2] == mmp.Conduit(sender='micro.out',
receiver='meso.in')
assert result.conduits[3] == mmp.Conduit(sender='meso.out',
receiver='macro.in')
assert mmp.PeerResult.PeerDimensions(
peer_name='micro', dimensions=[5, 10]) in result.peer_dimensions
assert mmp.PeerResult.PeerDimensions(
peer_name='macro', dimensions=[]) in result.peer_dimensions
assert mmp.PeerResult.PeerLocations(instance_name='macro',
locations=['direct:macro'
]) in result.peer_locations
for i in range(10):
instance = 'micro[2][{}]'.format(i)
location = 'direct:{}'.format(instance)
assert mmp.PeerResult.PeerLocations(
instance_name=instance,
locations=[location]) in result.peer_locations
def request_peers(self, name: Reference
) -> Tuple[List[Conduit],
Dict[Reference, List[int]],
Dict[Reference, List[str]]]:
"""Request connection information about peers.
This will repeat the request at an exponentially increasing
query interval at first, until it reaches the interval
specified by PEER_INTERVAL_MIN and PEER_INTERVAL_MAX. From
there on, intervals are drawn randomly from that range.
Args:
name: Name of the current instance.
Returns:
A tuple containing a list of conduits that this instance is
attached to, a dictionary of peer dimensions, which is
indexed by Reference to the peer kernel, and specifies how
many instances of that kernel there are, and a dictionary
of peer instance locations, indexed by Reference to a peer
instance, and containing for each peer instance a list of
network location strings at which it can be reached.
"""
sleep_time = 0.1
start_time = perf_counter()
request = mmp.PeerRequest(instance_name=str(name))
result = self.__client.RequestPeers(request)
while (result.status == mmp.RESULT_STATUS_PENDING and
perf_counter() < start_time + PEER_TIMEOUT and
sleep_time < PEER_INTERVAL_MIN):
sleep(sleep_time)
result = self.__client.RequestPeers(request)
sleep_time *= 1.5
while (result.status == mmp.RESULT_STATUS_PENDING and
perf_counter() < start_time + PEER_TIMEOUT):
sleep(uniform(PEER_INTERVAL_MIN, PEER_INTERVAL_MAX))
result = self.__client.RequestPeers(request)
if result.status == mmp.RESULT_STATUS_PENDING:
raise RuntimeError('Timeout waiting for peers to appear')
if result.status == mmp.RESULT_STATUS_ERROR:
raise RuntimeError('Error getting peers from manager: {}'.format(
result.error_message))
conduits = list(map(conduit_from_grpc, result.conduits))
peer_dimensions = dict()
for peer_dimension in result.peer_dimensions:
peer_dimensions[peer_dimension.peer_name] = \
peer_dimension.dimensions
peer_locations = dict()
for peer_location in result.peer_locations:
peer_locations[peer_location.instance_name] = \
peer_location.locations
return conduits, peer_dimensions, peer_locations
def test_request_peers_own_conduits(registered_mmp_servicer2):
request = mmp.PeerRequest(instance_name='macro')
result = registered_mmp_servicer2.RequestPeers(request, None)
assert result.status == mmp.RESULT_STATUS_SUCCESS
assert result.conduits[0] == mmp.Conduit(sender='macro.out',
receiver='meso.in')
assert result.conduits[1] == mmp.Conduit(sender='meso.out',
receiver='macro.in')
def test_request_peers_fanin(registered_mmp_servicer):
request = mmp.PeerRequest(instance_name='micro[4][3]')
result = registered_mmp_servicer.RequestPeers(request, None)
assert result.status == mmp.RESULT_STATUS_SUCCESS
assert result.conduits[0] == mmp.Conduit(sender='macro.out',
receiver='micro.in')
assert result.conduits[1] == mmp.Conduit(sender='micro.out',
receiver='macro.in')
assert result.peer_dimensions[0] == mmp.PeerResult.PeerDimensions(
peer_name='macro', dimensions=[])
assert result.peer_locations[0] == mmp.PeerResult.PeerLocations(
instance_name='macro', locations=['direct:macro'])
def test_request_peers_fanout(registered_mmp_servicer):
request = mmp.PeerRequest(instance_name='macro')
result = registered_mmp_servicer.RequestPeers(request, None)
assert result.status == mmp.RESULT_STATUS_SUCCESS
assert result.conduits[0] == mmp.Conduit(sender='macro.out',
receiver='micro.in')
assert result.conduits[1] == mmp.Conduit(sender='micro.out',
receiver='macro.in')
assert result.peer_dimensions[0] == mmp.PeerResult.PeerDimensions(
peer_name='micro', dimensions=[10, 10])
for i, peer_locations in enumerate(result.peer_locations):
instance = 'micro[{}][{}]'.format(i // 10, i % 10)
location = 'direct:{}'.format(instance)
assert peer_locations == mmp.PeerResult.PeerLocations(
instance_name=instance, locations=[location])
def test_request_peers_unknown(registered_mmp_servicer2):
request = mmp.PeerRequest(instance_name='does_not_exist')
result = registered_mmp_servicer2.RequestPeers(request, None)
assert result.status == mmp.RESULT_STATUS_ERROR
assert result.error_message is not None
assert 'does_not_exist' in result.error_message
def test_request_peers_pending(mmp_servicer):
request = mmp.PeerRequest(instance_name='micro[0][0]')
result = mmp_servicer.RequestPeers(request, None)
assert result.status == mmp.RESULT_STATUS_PENDING