Add missing trace. (#2578)

pymodbus/server/requesthandler.py

@@ -85,10 +85,7 @@ def callback_data(self, data: bytes, addr: tuple | None = None) -> int:
             self.server_send(response, 0)
             return(len(data))
         if self.last_pdu:
-            if self.is_server:
-                self.loop.call_soon(self.handle_later)
-            else:
-                self.response_future.set_result(True)
+            self.loop.call_soon(self.handle_later)
         return used_len
 
     def handle_later(self):

pymodbus/transaction/transaction.py

@@ -47,6 +47,7 @@ def __init__(
         self.framer = framer
         self.retries = retries
         self.next_tid: int = 0
+        self.request_dev_id: int = 0
         self.trace_packet = trace_packet or self.dummy_trace_packet
         self.trace_pdu = trace_pdu or self.dummy_trace_pdu
         self.trace_connect = trace_connect or self.dummy_trace_connect
@@ -84,15 +85,14 @@ def sync_get_response(self, dev_id) -> ModbusPDU:
             if not (data := self.sync_client.recv(None)):
                 raise asyncio.exceptions.TimeoutError()
             databuffer += data
-            used_len, pdu = self.framer.processIncomingFrame(databuffer)
+            used_len, pdu = self.framer.processIncomingFrame(self.trace_packet(False, databuffer))
             databuffer = databuffer[used_len:]
             if pdu:
                 if pdu.dev_id != dev_id:
                     raise ModbusIOException(
                         f"ERROR: request ask for id={dev_id} but id={pdu.dev_id}, CLOSING CONNECTION."
                     )
-
-                return pdu
+                return self.trace_pdu(False, pdu)
 
     def sync_execute(self, no_response_expected: bool, request: ModbusPDU) -> ModbusPDU:
         """Execute requests asynchronously.
@@ -148,7 +148,7 @@ async def execute(self, no_response_expected: bool, request: ModbusPDU) -> Modbu
                     self.count_until_disconnect= self.max_until_disconnect
                     if response.dev_id != request.dev_id:
                         raise ModbusIOException(
-                            f"ERROR: request ask for id={request.dev_id} but id={response.dev_id}, CLOSING CONNECTION."
+                            f"ERROR: request ask for id={request.dev_id} but got id={response.dev_id}, CLOSING CONNECTION."
                         )
                     return response
                 except asyncio.exceptions.TimeoutError:
@@ -165,6 +165,7 @@ async def execute(self, no_response_expected: bool, request: ModbusPDU) -> Modbu
 
     def pdu_send(self, pdu: ModbusPDU, addr: tuple | None = None) -> None:
         """Build byte stream and send."""
+        self.request_dev_id = pdu.dev_id
         packet = self.framer.buildFrame(self.trace_pdu(True, pdu))
         self.low_level_send(self.trace_packet(True, packet), addr=addr)
 
@@ -189,7 +190,11 @@ def callback_data(self, data: bytes, addr: tuple | None = None) -> int:
             self.last_pdu = self.trace_pdu(False, pdu)
             self.last_addr = addr
             if not self.is_server:
-                self.response_future.set_result(pdu)
+                if pdu.dev_id != self.request_dev_id:
+                    raise ModbusIOException(
+                        f"ERROR: request ask for id={self.request_dev_id} but got id={pdu.dev_id}, CLOSING CONNECTION."
+                    )
+                self.response_future.set_result(self.last_pdu)
         return used_len
 
     def getNextTID(self) -> int:

test/server/test_simulator.py

@@ -636,24 +636,24 @@ async def test_simulator_server_end_to_end(self, simulator_server, use_port):
         """Test simulator server end to end."""
         client = AsyncModbusTcpClient(NULLMODEM_HOST, port=use_port)
         assert await client.connect()
-        result = await client.read_holding_registers(16, count=1)
+        result = await client.read_holding_registers(16, count=1, slave=1)
         assert result.registers[0] == 3124
         client.close()
 
     async def test_simulator_server_string(self, simulator_server, use_port):
         """Test simulator server end to end."""
         client = AsyncModbusTcpClient(NULLMODEM_HOST, port=use_port)
         assert await client.connect()
-        result = await client.read_holding_registers(43, count=2)
+        result = await client.read_holding_registers(43, count=2, slave=1)
         assert result.registers[0] == int.from_bytes(bytes("St", "utf-8"), "big")
         assert result.registers[1] == int.from_bytes(bytes("r ", "utf-8"), "big")
-        result = await client.read_holding_registers(43, count=6)
+        result = await client.read_holding_registers(43, count=6, slave=1)
         assert result.registers[0] == int.from_bytes(bytes("St", "utf-8"), "big")
         assert result.registers[1] == int.from_bytes(bytes("r ", "utf-8"), "big")
         assert result.registers[2] == int.from_bytes(bytes("St", "utf-8"), "big")
         assert result.registers[3] == int.from_bytes(bytes("rx", "utf-8"), "big")
         assert result.registers[4] == int.from_bytes(bytes("yz", "utf-8"), "big")
         assert result.registers[5] == int.from_bytes(bytes("12", "utf-8"), "big")
-        result = await client.read_holding_registers(21, count=23)
+        result = await client.read_holding_registers(21, count=23, slave=1)
         assert len(result.registers) == 23
         client.close()

test/transaction/test_transaction.py

@@ -92,8 +92,9 @@ async def test_transaction_disconnect(self, use_clc):
     @pytest.mark.parametrize("test", [True, False])
     async def test_transaction_data(self, use_clc, test):
         """Test tracers in disconnect."""
-        pdu = "dummy pdu"
-        packet = b'123'
+        pdu = ExceptionResponse(0xff)
+        pdu.dev_id = 0
+        packet = b'\x00\x03\x00\x7c\x00\x02\x04\x02'
         transact = TransactionManager(
             use_clc,
             FramerRTU(DecodePDU(False)),
@@ -184,11 +185,11 @@ async def test_transaction_receiver(self, use_clc):
             None,
         )
         transact.send = mock.Mock()
-        response = ReadCoilsResponse(bits=[True, False, True, True, False])
+        response = ReadCoilsResponse(bits=[True, False, True, True, False], dev_id=0)
         transact.retries = 0
         transact.connection_made(mock.AsyncMock())
 
-        data = b"\x00\x00\x12\x34\x00\x06\xff\x01\x01\x02\x00\x04"
+        data = b"\x00\x00\x12\x34\x00\x06\x00\x01\x01\x02\x00\x04"
         transact.data_received(data)
         response = await transact.response_future
         assert isinstance(response, ReadCoilsResponse)