Framer, final touches. (#2360)

Author: janiversen

examples/message_parser.py

@@ -73,14 +73,14 @@ def decode(self, message):
         print(f"Decoding Message {value}")
         print("=" * 80)
         decoders = [
-            self.framer(ServerDecoder(), [0]),
-            self.framer(ClientDecoder(), [0]),
+            self.framer(ServerDecoder(), []),
+            self.framer(ClientDecoder(), []),
         ]
         for decoder in decoders:
-            print(f"{decoder.message_handler.decoder.__class__.__name__}")
+            print(f"{decoder.decoder.__class__.__name__}")
             print("-" * 80)
             try:
-                decoder.processIncomingPacket(message, self.report, 0)
+                decoder.processIncomingPacket(message, self.report)
             except Exception:  # pylint: disable=broad-except
                 self.check_errors(decoder, message)
 

pymodbus/client/base.py

@@ -210,7 +210,7 @@ def register(self, custom_response_class: ModbusResponse) -> None:
         Use register() to add non-standard responses (like e.g. a login prompt) and
         have them interpreted automatically.
         """
-        self.framer.message_handler.decoder.register(custom_response_class)
+        self.framer.decoder.register(custom_response_class)
 
     def idle_time(self) -> float:
         """Time before initiating next transaction (call **sync**).

pymodbus/client/modbusclientprotocol.py

@@ -35,7 +35,7 @@ def __init__(
         self.on_connect_callback = on_connect_callback
 
         # Common variables.
-        self.framer: FramerBase = (FRAMER_NAME_TO_CLASS[framer])(ClientDecoder(), [0])
+        self.framer: FramerBase = (FRAMER_NAME_TO_CLASS[framer])(ClientDecoder(), [])
         self.transaction = ModbusTransactionManager()
 
     def _handle_response(self, reply):
@@ -68,7 +68,7 @@ def callback_data(self, data: bytes, addr: tuple | None = None) -> int:
 
         returns number of bytes consumed
         """
-        self.framer.processIncomingPacket(data, self._handle_response, 0)
+        self.framer.processIncomingPacket(data, self._handle_response)
         return len(data)
 
     def __str__(self):

pymodbus/framer/base.py

@@ -36,11 +36,12 @@ def __init__(
     ) -> None:
         """Initialize a ADU (framer) instance."""
         self.decoder = decoder
+        if 0 in dev_ids:
+            dev_ids = []
         self.dev_ids = dev_ids
         self.incoming_dev_id = 0
         self.incoming_tid = 0
         self.databuffer = b""
-        self.message_handler = self
 
     def decode(self, data: bytes) -> tuple[int, bytes]:
         """Decode ADU.
@@ -85,7 +86,7 @@ def buildPacket(self, message: ModbusRequest | ModbusResponse) -> bytes:
         packet = self.encode(data, message.slave_id, message.transaction_id)
         return packet
 
-    def processIncomingPacket(self, data: bytes, callback, slave, tid=None):
+    def processIncomingPacket(self, data: bytes, callback, tid=None):
         """Process new packet pattern.
 
         This takes in a new request packet, adds it to the current
@@ -99,11 +100,6 @@ def processIncomingPacket(self, data: bytes, callback, slave, tid=None):
         """
         Log.debug("Processing: {}", data, ":hex")
         self.databuffer += data
-        if self.databuffer == b'':
-            return
-        if not isinstance(slave, (list, tuple)):
-            slave = [slave]
-        self.dev_ids = slave
         while True:
             if self.databuffer == b'':
                 return
@@ -112,7 +108,7 @@ def processIncomingPacket(self, data: bytes, callback, slave, tid=None):
                 self.databuffer = self.databuffer[used_len:]
             if not data:
                 return
-            if slave and 0 not in slave and self.incoming_dev_id not in slave:
+            if self.dev_ids and self.incoming_dev_id not in self.dev_ids:
                 Log.debug("Not a valid slave id - {}, ignoring!!", self.incoming_dev_id)
                 self.databuffer = b''
                 continue

pymodbus/framer/rtu.py

@@ -101,7 +101,7 @@ def specific_decode(self, data: bytes, data_len: int) -> tuple[int, bytes]:
                 return used_len, self.EMPTY
             self.incoming_dev_id = int(data[used_len])
             func_code = int(data[used_len + 1])
-            if (self.dev_ids[0] and self.incoming_dev_id not in self.dev_ids) or func_code & 0x7F not in self.decoder.lookup:
+            if (self.dev_ids and self.incoming_dev_id not in self.dev_ids) or func_code & 0x7F not in self.decoder.lookup:
                 continue
             if data_len - used_len < self.MIN_SIZE:
                     Log.debug("Garble in front {}, then short frame: {} wait for more data", used_len, data, ":hex")

pymodbus/server/async_io.py

@@ -64,11 +64,17 @@ def callback_new_connection(self) -> ModbusProtocol:
 
     def callback_connected(self) -> None:
         """Call when connection is succcesfull."""
+        slaves = self.server.context.slaves()
+        if self.server.broadcast_enable:
+            if 0 not in slaves:
+                slaves.append(0)
+        if 0 in slaves:
+            slaves = []
         try:
             self.running = True
             self.framer = self.server.framer(
                 self.server.decoder,
-                [0],
+                slaves,
             )
 
             # schedule the connection handler on the event loop
@@ -106,7 +112,6 @@ def callback_disconnected(self, call_exc: Exception | None) -> None:
 
     async def inner_handle(self):
         """Handle handler."""
-        slaves = self.server.context.slaves()
         # this is an asyncio.Queue await, it will never fail
         data = await self._recv_()
         if isinstance(data, tuple):
@@ -117,15 +122,10 @@ async def inner_handle(self):
 
         # if broadcast is enabled make sure to
         # process requests to address 0
-        if self.server.broadcast_enable:
-            if 0 not in slaves:
-                slaves.append(0)
-
         Log.debug("Handling data: {}", data, ":hex")
         self.framer.processIncomingPacket(
             data=data,
             callback=lambda x: self.execute(x, *addr),
-            slave=slaves,
         )
 
     async def handle(self) -> None:

pymodbus/transaction.py

@@ -187,10 +187,10 @@ def execute(self, request: ModbusRequest):  # noqa: C901
                 request.transaction_id = self.getNextTID()
                 Log.debug("Running transaction {}", request.transaction_id)
                 if _buffer := hexlify_packets(
-                    self.client.framer.message_handler.databuffer
+                    self.client.framer.databuffer
                 ):
                     Log.debug("Clearing current Frame: - {}", _buffer)
-                    self.client.framer.message_handler.databuffer = b''
+                    self.client.framer.databuffer = b''
                 broadcast = not request.slave_id
                 expected_response_length = None
                 if not isinstance(self.client.framer, FramerSocket):
@@ -235,7 +235,6 @@ def execute(self, request: ModbusRequest):  # noqa: C901
                 self.client.framer.processIncomingPacket(
                     response,
                     self.addTransaction,
-                    request.slave_id,
                     tid=request.transaction_id,
                 )
                 if not (response := self.getTransaction(request.transaction_id)):
@@ -259,7 +258,7 @@ def execute(self, request: ModbusRequest):  # noqa: C901
                     self.client.state = ModbusTransactionState.TRANSACTION_COMPLETE
                 return response
             except ModbusIOException as exc:
-                # Handle decode errors in processIncomingPacket method
+                # Handle decode errors method
                 Log.error("Modbus IO exception {}", exc)
                 self.client.state = ModbusTransactionState.TRANSACTION_COMPLETE
                 self.client.close()
@@ -425,5 +424,5 @@ def _get_expected_response_length(self, data) -> int:
         :return: Total frame size
         """
         func_code = int(data[1])
-        pdu_class = self.client.framer.message_handler.decoder.lookupPduClass(func_code)
+        pdu_class = self.client.framer.decoder.lookupPduClass(func_code)
         return pdu_class.calculateRtuFrameSize(data)

test/framers/test_multidrop.py

@@ -10,14 +10,12 @@
 class NotImplementedTestMultidrop:
     """Test that server works on a multidrop line."""
 
-    slaves = [2]
-
     good_frame = b"\x02\x03\x00\x01\x00}\xd4\x18"
 
     @pytest.fixture(name="framer")
     def fixture_framer(self):
         """Prepare framer."""
-        return FramerRTU(ServerDecoder(), [0])
+        return FramerRTU(ServerDecoder(), [2])
 
     @pytest.fixture(name="callback")
     def fixture_callback(self):
@@ -27,25 +25,25 @@ def fixture_callback(self):
     def test_ok_frame(self, framer, callback):
         """Test ok frame."""
         serial_event = self.good_frame
-        framer.processIncomingPacket(serial_event, callback, self.slaves)
+        framer.processIncomingPacket(serial_event, callback)
         callback.assert_called_once()
 
     def test_ok_2frame(self, framer, callback):
         """Test ok frame."""
         serial_event = self.good_frame + self.good_frame
-        framer.processIncomingPacket(serial_event, callback, self.slaves)
+        framer.processIncomingPacket(serial_event, callback)
         assert callback.call_count == 2
 
     def test_bad_crc(self, framer, callback):
         """Test bad crc."""
         serial_event = b"\x02\x03\x00\x01\x00}\xd4\x19"  # Manually mangled crc
-        framer.processIncomingPacket(serial_event, callback, self.slaves)
+        framer.processIncomingPacket(serial_event, callback)
         callback.assert_not_called()
 
     def test_wrong_id(self, framer, callback):
         """Test frame wrong id."""
         serial_event = b"\x01\x03\x00\x01\x00}\xd4+"  # Frame with good CRC but other id
-        framer.processIncomingPacket(serial_event, callback, self.slaves)
+        framer.processIncomingPacket(serial_event, callback)
         callback.assert_not_called()
 
     def test_big_split_response_frame_from_other_id(self, framer, callback):
@@ -64,67 +62,67 @@ def test_big_split_response_frame_from_other_id(self, framer, callback):
             b"\x00\x00\x00\x00\x00\x00\x00N,",
         ]
         for serial_event in serial_events:
-            framer.processIncomingPacket(serial_event, callback, self.slaves)
+            framer.processIncomingPacket(serial_event, callback)
         callback.assert_not_called()
 
     def test_split_frame(self, framer, callback):
         """Test split frame."""
         serial_events = [self.good_frame[:5], self.good_frame[5:]]
         for serial_event in serial_events:
-            framer.processIncomingPacket(serial_event, callback, self.slaves)
+            framer.processIncomingPacket(serial_event, callback)
         callback.assert_called_once()
 
     def test_complete_frame_trailing_data_without_id(self, framer, callback):
         """Test trailing data."""
         garbage = b"\x05\x04\x03"  # without id
         serial_event = garbage + self.good_frame
-        framer.processIncomingPacket(serial_event, callback, self.slaves)
+        framer.processIncomingPacket(serial_event, callback)
         callback.assert_called_once()
 
     def test_complete_frame_trailing_data_with_id(self, framer, callback):
         """Test trailing data."""
         garbage = b"\x05\x04\x03\x02\x01\x00"  # with id
         serial_event = garbage + self.good_frame
-        framer.processIncomingPacket(serial_event, callback, self.slaves)
+        framer.processIncomingPacket(serial_event, callback)
         callback.assert_called_once()
 
     def test_split_frame_trailing_data_with_id(self, framer, callback):
         """Test split frame."""
         garbage = b"\x05\x04\x03\x02\x01\x00"
         serial_events = [garbage + self.good_frame[:5], self.good_frame[5:]]
         for serial_event in serial_events:
-            framer.processIncomingPacket(serial_event, callback, self.slaves)
+            framer.processIncomingPacket(serial_event, callback)
         callback.assert_called_once()
 
     def test_coincidental_1(self, framer, callback):
         """Test conincidental."""
         garbage = b"\x02\x90\x07"
         serial_events = [garbage, self.good_frame[:5], self.good_frame[5:]]
         for serial_event in serial_events:
-            framer.processIncomingPacket(serial_event, callback, self.slaves)
+            framer.processIncomingPacket(serial_event, callback)
         callback.assert_called_once()
 
     def test_coincidental_2(self, framer, callback):
         """Test conincidental."""
         garbage = b"\x02\x10\x07"
         serial_events = [garbage, self.good_frame[:5], self.good_frame[5:]]
         for serial_event in serial_events:
-            framer.processIncomingPacket(serial_event, callback, self.slaves)
+            framer.processIncomingPacket(serial_event, callback)
         callback.assert_called_once()
 
     def test_coincidental_3(self, framer, callback):
         """Test conincidental."""
         garbage = b"\x02\x10\x07\x10"
         serial_events = [garbage, self.good_frame[:5], self.good_frame[5:]]
         for serial_event in serial_events:
-            framer.processIncomingPacket(serial_event, callback, self.slaves)
+            framer.processIncomingPacket(serial_event, callback)
         callback.assert_called_once()
 
     def test_wrapped_frame(self, framer, callback):
         """Test wrapped frame."""
         garbage = b"\x05\x04\x03\x02\x01\x00"
         serial_event = garbage + self.good_frame + garbage
-        framer.processIncomingPacket(serial_event, callback, self.slaves)
+        framer.processIncomingPacket(serial_event, callback)
 
         # We probably should not respond in this case; in this case we've likely become desynchronized
         # i.e. this probably represents a case where a command came for us, but we didn't get
@@ -136,7 +134,7 @@ def test_frame_with_trailing_data(self, framer, callback):
         """Test trailing data."""
         garbage = b"\x05\x04\x03\x02\x01\x00"
         serial_event = self.good_frame + garbage
-        framer.processIncomingPacket(serial_event, callback, self.slaves)
+        framer.processIncomingPacket(serial_event, callback)
 
         # We should not respond in this case for identical reasons as test_wrapped_frame
         callback.assert_called_once()
@@ -152,23 +150,23 @@ def test_callback(data):
             result = data.function_code.to_bytes(1,'big')+data.encode()
 
         framer_ok = b"\x02\x03\x00\x01\x00\x7d\xd4\x18"
-        framer.processIncomingPacket(framer_ok, test_callback, self.slaves)
+        framer.processIncomingPacket(framer_ok, test_callback)
         assert framer_ok[1:-2] == result
 
         count = 0
         framer_2ok = framer_ok + framer_ok
-        framer.processIncomingPacket(framer_2ok, test_callback, self.slaves)
+        framer.processIncomingPacket(framer_2ok, test_callback)
         assert count == 2
         assert not framer._buffer  # pylint: disable=protected-access
 
         framer._buffer = framer_ok[:2]  # pylint: disable=protected-access
-        framer.processIncomingPacket(b'', test_callback, self.slaves)
+        framer.processIncomingPacket(b'', test_callback)
         assert framer_ok[:2] == framer._buffer  # pylint: disable=protected-access
 
         framer._buffer = framer_ok[:3]  # pylint: disable=protected-access
-        framer.processIncomingPacket(b'', test_callback, self.slaves)
+        framer.processIncomingPacket(b'', test_callback)
         assert framer_ok[:3] == framer._buffer  # pylint: disable=protected-access
 
         framer_ok = b"\xF0\x03\x00\x01\x00}\xd4\x18"
-        framer.processIncomingPacket(framer_ok, test_callback, self.slaves)
+        framer.processIncomingPacket(framer_ok, test_callback)
         assert framer._buffer == framer_ok[-3:]  # pylint: disable=protected-access

test/sub_client/test_client_faulty_response.py

@@ -11,14 +11,12 @@
 class TestFaultyResponses:
     """Test that server works on a multidrop line."""
 
-    slaves = [0]
-
     good_frame = b"\x00\x01\x00\x00\x00\x05\x00\x03\x02\x00\x01"
 
     @pytest.fixture(name="framer")
     def fixture_framer(self):
         """Prepare framer."""
-        return FramerSocket(ClientDecoder(), [0])
+        return FramerSocket(ClientDecoder(), [])
 
     @pytest.fixture(name="callback")
     def fixture_callback(self):
@@ -27,21 +25,21 @@ def fixture_callback(self):
 
     def test_ok_frame(self, framer, callback):
         """Test ok frame."""
-        framer.processIncomingPacket(self.good_frame, callback, self.slaves)
+        framer.processIncomingPacket(self.good_frame, callback)
         callback.assert_called_once()
 
     def test_1917_frame(self, callback):
         """Test invalid frame in issue 1917."""
         recv = b"\x01\x86\x02\x00\x01"
         framer = FramerRTU(ClientDecoder(), [0])
-        framer.processIncomingPacket(recv, callback, self.slaves)
+        framer.processIncomingPacket(recv, callback)
         callback.assert_not_called()
 
     def test_faulty_frame1(self, framer, callback):
         """Test ok frame."""
         faulty_frame = b"\x00\x04\x00\x00\x00\x05\x00\x03\x0a\x00\x04"
         with pytest.raises(ModbusIOException):
-            framer.processIncomingPacket(faulty_frame, callback, self.slaves)
+            framer.processIncomingPacket(faulty_frame, callback)
         callback.assert_not_called()
-        framer.processIncomingPacket(self.good_frame, callback, self.slaves)
+        framer.processIncomingPacket(self.good_frame, callback)
         callback.assert_called_once()

test/sub_client/test_client_sync.py

@@ -206,7 +206,7 @@ class CustomRequest:  # pylint: disable=too-few-public-methods
         client = ModbusTcpClient("127.0.0.1")
         client.framer = mock.Mock()
         client.register(CustomRequest)
-        client.framer.message_handler.decoder.register.assert_called_once_with(CustomRequest)
+        client.framer.decoder.register.assert_called_once_with(CustomRequest)
 
     # -----------------------------------------------------------------------#
     # Test TLS Client
@@ -296,7 +296,7 @@ class CustomRequest:  # pylint: disable=too-few-public-methods
         client = ModbusTlsClient("127.0.0.1")
         client.framer = mock.Mock()
         client.register(CustomRequest)
-        client.framer.message_handler.decoder.register.assert_called_once_with(CustomRequest)
+        client.framer.decoder.register.assert_called_once_with(CustomRequest)
 
     # -----------------------------------------------------------------------#
     # Test Serial Client