def test_clear_iobuf_process(self):
receiver = MockMachine()
receiver.start()
# Set up a connection to the "machine"
connection = SCAMPConnection(0,
0,
remote_host="127.0.0.1",
remote_port=receiver.local_port)
selector = RoundRobinConnectionSelector([connection])
# Create the process and run it
process = ClearIOBUFProcess(selector)
process.clear_iobuf(CoreSubsets([CoreSubset(0, 0, [1])]), 1)
receiver.stop()
# Check the message received
self.assertTrue(receiver.is_next_message)
data = receiver.next_message
sdp_header = SDPHeader.from_bytestring(data, 2)
self.assertEqual(sdp_header.destination_chip_x, 0)
self.assertEqual(sdp_header.destination_chip_y, 0)
self.assertEqual(sdp_header.destination_cpu, 1)
command = struct.unpack_from("<H", data, 10)[0]
self.assertEqual(command,
SDP_RUNNING_MESSAGE_CODES.SDP_CLEAR_IOBUF_CODE.value)
def test_clear_iobuf_process(self):
receiver = MockMachine()
receiver.start()
# Set up a connection to the "machine"
connection = SCAMPConnection(
0, 0, remote_host="127.0.0.1", remote_port=receiver.local_port)
selector = RoundRobinConnectionSelector([connection])
# Create the process and run it
process = ClearIOBUFProcess(selector)
process.clear_iobuf(CoreSubsets([CoreSubset(0, 0, [1])]), 1)
receiver.stop()
# Check the message received
self.assertTrue(receiver.is_next_message)
data = receiver.next_message
sdp_header = SDPHeader.from_bytestring(data, 2)
self.assertEqual(sdp_header.destination_chip_x, 0)
self.assertEqual(sdp_header.destination_chip_y, 0)
self.assertEqual(sdp_header.destination_cpu, 1)
command, = struct.unpack_from("<H", data, 10)
self.assertEqual(
command,
SDP_RUNNING_MESSAGE_CODES.SDP_CLEAR_IOBUF_CODE.value)
def read_bytestring(self, data, offset):
""" Reads a packet from a bytestring of data
:param bytes data: The bytestring to be read
:param int offset:
The offset in the data from which the response should be read
"""
self._sdp_header = SDPHeader.from_bytestring(data, offset)
self._scp_response_header = SCPResponseHeader.from_bytestring(
data, _SCP_HEADER_OFFSET + offset)
self.read_data_bytestring(data, _SCP_DATA_OFFSET + offset)
def read_bytestring(self, data, offset):
""" Reads a packet from a bytestring of data
:param data: The bytestring to be read
:type data: str
:param offset: \
The offset in the data from which the response should be read
:type offset: int
"""
self._sdp_header = SDPHeader.from_bytestring(data, offset)
self._scp_response_header = SCPResponseHeader.from_bytestring(
data, _SCP_HEADER_OFFSET + offset)
self.read_data_bytestring(data, _SCP_DATA_OFFSET + offset)
def _do_receive(self):
data, address = self._receiver.receive_with_address()
self._messages.append(data)
sdp_header = SDPHeader.from_bytestring(data, 2)
response = None
if self._responses:
response = self._responses.popleft()
else:
response = _SCPOKMessage(sdp_header.source_chip_x,
sdp_header.source_chip_y)
if response is not None:
self._receiver.send_to(
struct.pack("<2x") + response.bytestring, address)
def _do_receive(self):
data, address = self._receiver.receive_with_address(10)
sdp_header = SDPHeader.from_bytestring(data, 2)
_, sequence = self._SCP_HEADER.unpack_from(data, 10)
response = None
if self._responses:
response = self._responses.popleft()
else: # pragma: no cover
response = SCPOKMessage(sdp_header.source_chip_x,
sdp_header.source_chip_y, sequence)
if hasattr(response, "set_sequence"):
response.set_sequence(sequence)
if response is not None:
self._receiver.send_to(self._TWO_NUL_BYTES + response.bytestring,
address)
def _do_receive(self):
data, address = self._receiver.receive_with_address()
self._messages.append(data)
sdp_header = SDPHeader.from_bytestring(data, 2)
_result, sequence = struct.unpack_from("<2H", data, 10)
response = None
if self._responses:
response = self._responses.popleft()
response._data = (response._data[:10] +
struct.pack("<H", sequence) +
response._data[12:])
else:
response = _SCPOKMessage(sdp_header.source_chip_x,
sdp_header.source_chip_y, sequence)
if response is not None:
self._receiver.send_to(
struct.pack("<2x") + response.bytestring, address)
def _do_receive(self):
data, address = self._receiver.receive_with_address()
self._messages.append(data)
sdp_header = SDPHeader.from_bytestring(data, 2)
_result, sequence = struct.unpack_from("<2H", data, 10)
response = None
if self._responses:
response = self._responses.popleft()
response._data = (
response._data[:10] + struct.pack("<H", sequence) +
response._data[12:])
else:
response = _SCPOKMessage(
sdp_header.source_chip_x, sdp_header.source_chip_y,
sequence)
if response is not None:
self._receiver.send_to(
struct.pack("<2x") + response.bytestring, address)
def run(self):
self._running = True
while self._running:
try:
if self._receiver.is_ready_to_receive(10):
data, address = self._receiver.receive_with_address()
self._messages.append(data)
sdp_header = SDPHeader.from_bytestring(data, 2)
response = None
if len(self._responses) > 0:
response = self._responses.popleft()
else:
response = _SCPOKMessage(sdp_header.source_chip_x,
sdp_header.source_chip_y)
if response is not None:
self._receiver.send_to(
struct.pack("<2x") + response.bytestring, address)
except Exception as e:
if self._running:
traceback.print_exc()
self._error = e
