Merge branch '3.0.0' into remove_python2_compatibility_code

Author: swamper123

CHANGELOG.rst

@@ -1,11 +1,25 @@
+
+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.3
 ----------------------------------------------------------
 * Fix retries on tcp client failing randomly.
 * Fix Asyncio client timeout arg not being used.
 * Treat exception codes as valid responses
 * Fix examples (modbus_payload)
 * Add missing identity argument to async ModbusSerialServer
-
 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

@@ -49,6 +49,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)
 
@@ -143,7 +144,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:
@@ -168,9 +169,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)
@@ -198,12 +201,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

@@ -128,7 +128,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

@@ -108,7 +108,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)

examples/tools/test_install.sh

@@ -16,7 +16,7 @@ elif [[ "`which easy_install`" != "" ]]; then
     INSTALL="easy_install -qU"
 else
     echo -e "\E[31m"
-    echo "\E[31mPlease install distutils before continuing"
+    echo "\E[31mPlease install setuptools before continuing"
     echo "wget http://peak.telecommunity.com/dist/ez_setup.py | sudo python"
     echo -e "\E[0m"
     exit -1