def send_message(self,
port_name: str,
message: Message,
slot: Optional[int] = None) -> None:
"""Send a message and settings to the outside world.
Sending is non-blocking, a copy of the message will be made
and stored until the receiver is ready to receive it.
Args:
port_name: The port on which this message is to be sent.
message: The message to be sent.
slot: The slot to send the message on, if any.
"""
if slot is None:
slot_list = [] # type: List[int]
else:
slot_list = [slot]
slot_length = self._ports[port_name].get_length()
if slot_length <= slot:
raise RuntimeError(('Slot out of bounds. You are sending on'
' slot {} of port "{}", which is of length'
' {}, so that slot does not exist').format(
slot, port_name, slot_length))
snd_endpoint = self.__get_endpoint(port_name, slot_list)
if not self._peer_manager.is_connected(snd_endpoint.port):
# log sending on disconnected port
return
port = self._ports[port_name]
profile_event = self._profiler.start(ProfileEventType.SEND, port, None,
slot, None)
recv_endpoint = self._peer_manager.get_peer_endpoint(
snd_endpoint.port, slot_list)
port_length = None
if self._ports[port_name].is_resizable():
port_length = self._ports[port_name].get_length()
mcp_message = MCPMessage(snd_endpoint.ref(), recv_endpoint.ref(),
port_length, message.timestamp,
message.next_timestamp,
cast(Settings,
message.settings), message.data)
encoded_message = mcp_message.encoded()
self._post_office.deposit(recv_endpoint.ref(), encoded_message)
profile_event.stop()
if port.is_vector():
profile_event.port_length = port.get_length()
profile_event.message_size = len(encoded_message)
def test_receive_close_port(communicator) -> None:
client_mock = MagicMock()
client_mock.receive.return_value = MCPMessage(Reference('other.out[13]'),
Reference('kernel[13].in'),
None, 0.0, None, Settings(),
ClosePort()).encoded()
get_client_mock = MagicMock(return_value=client_mock)
communicator._Communicator__get_client = get_client_mock
communicator._profiler = MagicMock()
msg = communicator.receive_message('in')
assert isinstance(msg.data, ClosePort)
def test_receive_msgpack_with_slot_and_settings(communicator2) -> None:
client_mock = MagicMock()
client_mock.receive.return_value = MCPMessage(
Reference('kernel[13].out'), Reference('other.in[13]'), None, 0.0, 1.0,
Settings({'test': 'testing'}), 'test').encoded()
get_client_mock = MagicMock(return_value=client_mock)
communicator2._Communicator__get_client = get_client_mock
communicator2._profiler = MagicMock()
msg = communicator2.receive_message('in', 13)
get_client_mock.assert_called_with(Reference('kernel[13]'))
client_mock.receive.assert_called_with(Reference('other.in[13]'))
assert msg.data == 'test'
assert msg.settings['test'] == 'testing'
def test_receive_message_resizable(communicator3) -> None:
client_mock = MagicMock()
client_mock.receive.return_value = MCPMessage(
Reference('other.out[13]'), Reference('kernel.in[13]'), 20, 0.0, None,
Settings({'test': 'testing'}), b'test').encoded()
get_client_mock = MagicMock(return_value=client_mock)
communicator3._Communicator__get_client = get_client_mock
communicator3._profiler = MagicMock()
msg = communicator3.receive_message('in', 13)
get_client_mock.assert_called_with(Reference('other'))
client_mock.receive.assert_called_with(Reference('kernel.in[13]'))
assert msg.data == b'test'
assert communicator3.get_port('in').get_length() == 20
def test_receive_with_settings(communicator) -> None:
client_mock = MagicMock()
client_mock.receive.return_value = MCPMessage(Reference('other.out[13]'),
Reference('kernel[13].in'),
None, 0.0, None,
Settings({'test2': 3.1}),
b'test').encoded()
get_client_mock = MagicMock(return_value=client_mock)
communicator._Communicator__get_client = get_client_mock
communicator._profiler = MagicMock()
msg = communicator.receive_message('in')
get_client_mock.assert_called_with(Reference('other'))
client_mock.receive.assert_called_with(Reference('kernel[13].in'))
assert msg.data == b'test'
assert msg.settings['test2'] == 3.1
def test_receive_settings(communicator) -> None:
client_mock = MagicMock()
client_mock.receive.return_value = MCPMessage(Reference('other.out[13]'),
Reference('kernel[13].in'),
None, 0.0, None,
Settings({'test1': 12}),
Settings({'test':
13})).encoded()
get_client_mock = MagicMock(return_value=client_mock)
communicator._Communicator__get_client = get_client_mock
communicator._profiler = MagicMock()
msg = communicator.receive_message('in')
get_client_mock.assert_called_with(Reference('other'))
client_mock.receive.assert_called_with(Reference('kernel[13].in'))
assert isinstance(msg.data, Settings)
assert msg.data['test'] == 13
def test_get_message(communicator, message) -> None:
communicator.send_message('out', message)
ref_message = MCPMessage(Reference('kernel[13].out'),
Reference('other.in[13]'), None, 0.0, None,
Settings(), b'test').encoded()
assert communicator._post_office.get_message('other.in[13]') == ref_message