3.0.0

.github/workflows/ci.yml

@@ -34,8 +34,6 @@ jobs:
             runs-on: ubuntu-latest
             matrix: linux
             container:
-              2.7: docker://python:2.7-buster
-              3.6: docker://python:3.6-buster
               3.7: docker://python:3.7-buster
               3.8: docker://python:3.8-buster
               3.9: docker://python:3.9-buster
@@ -51,25 +49,6 @@ jobs:
               x86: win32
               x64: win64
         python:
-          - name: CPython 2.7
-            tox: py27
-            action: 2.7
-            docker: 2.7
-            matrix: 2.7
-            implementation: cpython
-          - name: PyPy 2.7
-            tox: pypy27
-            action: pypy-2.7
-            docker: pypy2.7
-            matrix: 2.7
-            implementation: pypy
-            openssl_msvc_version: 2019
-          - name: CPython 3.6
-            tox: py36
-            action: 3.6
-            docker: 3.6
-            matrix: 3.6
-            implementation: cpython
           - name: CPython 3.7
             tox: py37
             action: 3.7
@@ -88,13 +67,6 @@ jobs:
             docker: 3.9
             matrix: 3.9
             implementation: cpython
-          - name: PyPy 3.6
-            tox: pypy36
-            action: pypy-3.6
-            docker: pypy3.6
-            matrix: 3.6
-            implementation: pypy
-            openssl_msvc_version: 2019
           - name: PyPy 3.7
             tox: pypy37
             action: pypy-3.7

CHANGELOG.rst

@@ -1,3 +1,18 @@
+version 3.0.0dev1
+----------------------------------------------------------
+* Support python3.10
+* Implement asyncio ModbusSerialServer
+* ModbusTLS updates (tls handshake, default framer)
+* Support broadcast messages with asyncio client
+* Fix for lazy loading serial module with asyncio clients.
+* Updated examples and tests
+
+
+version 3.0.0dev0
+----------------------------------------------------------
+* Support python3.7 and above
+* Support creating asyncio clients from with in coroutines.
+
 version 2.5.2
 ----------------------------------------------------------
 * Add kwarg `reset_socket` to control closing of the socket on read failures (set to `True` by default).

examples/common/async_asyncio_client.py

@@ -55,6 +55,7 @@ async def start_async_test(client):
     # individual request. This can be done by specifying the `unit` parameter
     # which defaults to `0x00`
     # ----------------------------------------------------------------------- #
+    # client = await client
     log.debug("Reading Coils")
     rr = await client.read_coils(1, 1, unit=0x01)
 
@@ -149,7 +150,7 @@ def run_with_not_running_loop():
     log.debug("")
 
 
-def run_with_already_running_loop():
+async def run_with_already_running_loop():
     """
     An already running loop is passed to ModbusClient Factory
     :return:
@@ -174,9 +175,11 @@ def start_loop(loop):
     t.daemon = True
     # Start the loop
     t.start()
+    time.sleep(1)
     assert loop.is_running()
     asyncio.set_event_loop(loop)
     loop, client = ModbusClient(schedulers.ASYNC_IO, port=5020, loop=loop)
+    # client = await client
     future = asyncio.run_coroutine_threadsafe(
         start_async_test(client.protocol), loop=loop)
     future.add_done_callback(done)
@@ -204,12 +207,12 @@ def run_with_no_loop():
     # Run with No loop
     log.debug("Running Async client")
     log.debug("------------------------------------------------------")
-    run_with_no_loop()
+    # run_with_no_loop()
 
     # Run with loop not yet started
     # run_with_not_running_loop()
 
     # Run with already running loop
-    # run_with_already_running_loop()
+    asyncio.run(run_with_already_running_loop())
 
     log.debug("")

examples/common/async_asyncio_serial_client.py

@@ -133,7 +133,7 @@ async def start_async_test(client):
     # ----------------------------------------------------------------------- #
     # socat -d -d PTY,link=/tmp/ptyp0,raw,echo=0,ispeed=9600 PTY,
     # link=/tmp/ttyp0,raw,echo=0,ospeed=9600
-    loop, client = ModbusClient(schedulers.ASYNC_IO, port='/tmp/ptyp0',
+    loop, client = ModbusClient(schedulers.ASYNC_IO, port='/tmp/ttyp0',
                                 baudrate=9600, method="rtu")
     loop.run_until_complete(start_async_test(client.protocol))
     loop.close()

examples/common/asyncio_server.py

@@ -131,7 +131,13 @@ async def run_server():
 
     # Tls:
     # await StartTlsServer(context, identity=identity, address=("localhost", 8020),
-    #                      certfile="server.crt", keyfile="server.key",
+    #                      certfile="server.crt", keyfile="server.key", password="pwd",
+    #                      allow_reuse_address=True, allow_reuse_port=True,
+    #                      defer_start=False)
+
+    # Tls and force require client's certificate for TLS full handshake:
+    # await StartTlsServer(context, identity=identity, address=("localhost", 8020),
+    #                      certfile="server.crt", keyfile="server.key", password="pwd", reqclicert=True,
     #                      allow_reuse_address=True, allow_reuse_port=True,
     #                      defer_start=False)
 
@@ -141,17 +147,16 @@ async def run_server():
     # #
     # await server.serve_forever()
 
-    # !!! SERIAL SERVER NOT IMPLEMENTED !!!
     # Ascii:
-    # StartSerialServer(context, identity=identity,
-    #                    port='/dev/ttyp0', timeout=1)
+    # await StartSerialServer(context, identity=identity,
+    #                    port='/dev/ttyp0', timeout=1, autoreconnect=True)
 
     # RTU:
-    # StartSerialServer(context, framer=ModbusRtuFramer, identity=identity,
-    #                   port='/dev/ttyp0', timeout=.005, baudrate=9600)
+    # await StartSerialServer(context, framer=ModbusRtuFramer, identity=identity,
+    #                    port='/dev/ttyp0', timeout=.005, baudrate=9600, autoreconnect=True)
 
     # Binary
-    # StartSerialServer(context,
+    # await StartSerialServer(context,
     #                   identity=identity,
     #                   framer=ModbusBinaryFramer,
     #                   port='/dev/ttyp0',

examples/common/synchronous_server.py

@@ -113,15 +113,21 @@ def run_server():
     # run the server you want
     # ----------------------------------------------------------------------- #
     # Tcp:
-    StartTcpServer(context, identity=identity, address=("", 5020))
+    # StartTcpServer(context, identity=identity, address=("", 5020))
     #
     # TCP with different framer
     # StartTcpServer(context, identity=identity,
     #                framer=ModbusRtuFramer, address=("0.0.0.0", 5020))
 
     # TLS
-    # StartTlsServer(context, identity=identity, certfile="server.crt",
-    #                keyfile="server.key", address=("0.0.0.0", 8020))
+    # StartTlsServer(context, identity=identity,
+    #                certfile="server.crt", keyfile="server.key", password="pwd",
+    #                address=("0.0.0.0", 8020))
+
+    # Tls and force require client's certificate for TLS full handshake:
+    # StartTlsServer(context, identity=identity,
+    #                certfile="server.crt", keyfile="server.key", password="pwd", reqclicert=True,
+    #                address=("0.0.0.0", 8020))
 
     # Udp:
     # StartUdpServer(context, identity=identity, address=("0.0.0.0", 5020))

examples/contrib/asynchronous_asyncio_modbus_tls_client.py

@@ -17,11 +17,14 @@
 # -------------------------------------------------------------------------- #
 # the TLS detail security can be set in SSLContext which is the context here
 # -------------------------------------------------------------------------- #
-context = ssl.create_default_context()
-context.options |= ssl.OP_NO_SSLv2
-context.options |= ssl.OP_NO_SSLv3
-context.options |= ssl.OP_NO_TLSv1
-context.options |= ssl.OP_NO_TLSv1_1
+sslctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
+sslctx.verify_mode = ssl.CERT_REQUIRED
+sslctx.check_hostname = True
+
+# Prepare client's certificate which the server requires for TLS full handshake
+# sslctx.load_cert_chain(certfile="client.crt", keyfile="client.key",
+#                        password="pwd")
+
 
 async def start_async_test(client):
     result = await client.read_coils(1, 8)
@@ -31,10 +34,10 @@ async def start_async_test(client):
     print(result.bits)
 
 if __name__ == '__main__':
-# -------------------------------------------------------------------------- #
-# pass SSLContext which is the context here to ModbusTcpClient()
-# -------------------------------------------------------------------------- #
+    # ----------------------------------------------------------------------- #
+    # pass SSLContext which is the context here to ModbusTcpClient()
+    # ----------------------------------------------------------------------- #
     loop, client = AsyncModbusTLSClient(ASYNC_IO, 'test.host.com', 8020,
-                                        sslctx=context)
+                                        sslctx=sslctx)
     loop.run_until_complete(start_async_test(client.protocol))
     loop.close()

examples/contrib/asynchronous_asyncio_serial_client.py

@@ -114,7 +114,7 @@ def make_protocol():
 
 if __name__ == '__main__':
     loop = asyncio.get_event_loop()
-    coro = create_serial_connection(loop, make_protocol, '/dev/ptyp0',
+    coro = create_serial_connection(loop, make_protocol, '/tmp/ttyp0',
                                     baudrate=9600)
     transport, protocol = loop.run_until_complete(asyncio.gather(coro))[0]
     loop.run_until_complete(start_async_test(protocol))

examples/contrib/modbus_tls_client.py

@@ -16,16 +16,18 @@
 # -------------------------------------------------------------------------- #
 # the TLS detail security can be set in SSLContext which is the context here
 # -------------------------------------------------------------------------- #
-context = ssl.create_default_context()
-context.options |= ssl.OP_NO_SSLv2
-context.options |= ssl.OP_NO_SSLv3
-context.options |= ssl.OP_NO_TLSv1
-context.options |= ssl.OP_NO_TLSv1_1
+sslctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1_2)
+sslctx.verify_mode = ssl.CERT_REQUIRED
+sslctx.check_hostname = True
+
+# Prepare client's certificate which the server requires for TLS full handshake
+# sslctx.load_cert_chain(certfile="client.crt", keyfile="client.key",
+#                        password="pwd")
 
 # -------------------------------------------------------------------------- #
 # pass SSLContext which is the context here to ModbusTcpClient()
 # -------------------------------------------------------------------------- #
-client = ModbusTlsClient('test.host.com', 8020, sslctx=context)
+client = ModbusTlsClient('test.host.com', 8020, sslctx=sslctx)
 client.connect()
 
 result = client.read_coils(1, 8)