def test_factory_protocol_lost_connection(self, mock_async):
mock_protocol_class = mock.MagicMock()
mock_loop = mock.MagicMock()
client = ReconnectingAsyncioModbusTcpClient(
protocol_class=mock_protocol_class, loop=mock_loop)
assert not client.connected
assert client.protocol is None
client.protocol_lost_connection(mock.sentinel.PROTOCOL_UNEXPECTED)
assert not client.connected
# fake client ist connected and *then* looses connection:
client.connected = True
client.host = mock.sentinel.HOST
client.port = mock.sentinel.PORT
client.protocol = mock.sentinel.PROTOCOL
with mock.patch(
'pymodbus.client.asynchronous.async_io.ReconnectingAsyncioModbusTcpClient._reconnect'
) as mock_reconnect:
mock_reconnect.return_value = mock.sentinel.RECONNECT_GENERATOR
client.protocol_lost_connection(mock.sentinel.PROTOCOL)
if PYTHON_VERSION <= (3, 7):
mock_async.assert_called_once_with(
mock.sentinel.RECONNECT_GENERATOR, loop=mock_loop)
assert not client.connected
assert client.protocol is None
def __init__(self, address, timeout=1):
"""Set up communication parameters."""
self.ip = address
self.timeout = timeout
self.client = ReconnectingAsyncioModbusTcpClient()
asyncio.ensure_future(self._connect())
self.open = False
self.waiting = False
def test_factory_start_success(self, mock_async):
mock_protocol_class = mock.MagicMock()
mock_loop = mock.MagicMock()
client = ReconnectingAsyncioModbusTcpClient(
protocol_class=mock_protocol_class, loop=mock_loop)
run_coroutine(client.start(mock.sentinel.HOST, mock.sentinel.PORT))
mock_loop.create_connection.assert_called_once_with(
mock.ANY, mock.sentinel.HOST, mock.sentinel.PORT)
assert mock_async.call_count == 0
def test_factory_reset_wait_before_reconnect(self):
mock_protocol_class = mock.MagicMock()
mock_loop = mock.MagicMock()
client = ReconnectingAsyncioModbusTcpClient(protocol_class=mock_protocol_class, loop=mock_loop)
initial_delay = client.delay_ms
assert initial_delay > 0
client.delay_ms *= 2
assert client.delay_ms > initial_delay
client.reset_delay()
assert client.delay_ms == initial_delay
def test_factory_reconnect(self, mock_sleep):
mock_protocol_class = mock.MagicMock()
mock_loop = mock.MagicMock()
client = ReconnectingAsyncioModbusTcpClient(protocol_class=mock_protocol_class, loop=mock_loop)
client.delay_ms = 5000
mock_sleep.side_effect = return_as_coroutine()
run_coroutine(client._reconnect())
mock_sleep.assert_called_once_with(5)
assert mock_loop.create_connection.call_count == 1
def test_factory_start_failing_and_retried(self, mock_async):
mock_protocol_class = mock.MagicMock()
mock_loop = mock.MagicMock()
mock_loop.create_connection = mock.MagicMock(side_effect=Exception('Did not work.'))
client = ReconnectingAsyncioModbusTcpClient(protocol_class=mock_protocol_class, loop=mock_loop)
# check whether reconnect is called upon failed connection attempt:
with mock.patch('pymodbus.client.asynchronous.async_io.ReconnectingAsyncioModbusTcpClient._reconnect') as mock_reconnect:
mock_reconnect.return_value = mock.sentinel.RECONNECT_GENERATOR
run_coroutine(client.start(mock.sentinel.HOST, mock.sentinel.PORT))
mock_reconnect.assert_called_once_with()
if PYTHON_VERSION <= (3, 7):
mock_async.assert_called_once_with(mock.sentinel.RECONNECT_GENERATOR, loop=mock_loop)
async def test_factory_start_success(self):
mock_protocol_class = mock.MagicMock()
# mock_loop = mock.MagicMock()
client = ReconnectingAsyncioModbusTcpClient(protocol_class=mock_protocol_class)
# client = ReconnectingAsyncioModbusTcpClient(protocol_class=mock_protocol_class, loop=mock_loop)
await client.start(mock.sentinel.HOST, mock.sentinel.PORT)
def test_factory_initialization_state(self):
mock_protocol_class = mock.MagicMock()
mock_loop = mock.MagicMock()
client = ReconnectingAsyncioModbusTcpClient(protocol_class=mock_protocol_class, loop=mock_loop)
assert not client.connected
assert client.delay_ms < client.DELAY_MAX_MS
assert client.loop is mock_loop
assert client.protocol_class is mock_protocol_class
def test_factory_stop(self):
mock_protocol_class = mock.MagicMock()
mock_loop = mock.MagicMock()
client = ReconnectingAsyncioModbusTcpClient(protocol_class=mock_protocol_class, loop=mock_loop)
assert not client.connected
client.stop()
assert not client.connected
# fake connected client:
client.protocol = mock.MagicMock()
client.connected = True
client.stop()
client.protocol.transport.close.assert_called_once_with()
def test_factory_protocol_made_connection(self):
mock_protocol_class = mock.MagicMock()
mock_loop = mock.MagicMock()
client = ReconnectingAsyncioModbusTcpClient(protocol_class=mock_protocol_class, loop=mock_loop)
assert not client.connected
assert client.protocol is None
client.protocol_made_connection(mock.sentinel.PROTOCOL)
assert client.connected
assert client.protocol is mock.sentinel.PROTOCOL
client.protocol_made_connection(mock.sentinel.PROTOCOL_UNEXPECTED)
assert client.connected
assert client.protocol is mock.sentinel.PROTOCOL
class AsyncioModbusClient(object):
"""A generic asyncio client.
This expands upon the pymodbus ReconnectionAsyncioModbusTcpClient by
including standard timeouts, async context manager, and queued requests.
"""
def __init__(self, address, timeout=1):
"""Set up communication parameters."""
self.ip = address
self.timeout = timeout
self.client = ReconnectingAsyncioModbusTcpClient()
asyncio.ensure_future(self._connect())
self.open = False
self.waiting = False
async def __aenter__(self):
"""Asynchronously connect with the context manager."""
await self._connect()
return self
async def __aexit__(self, *args):
"""Provide exit to the context manager."""
self._close()
async def _connect(self):
"""Start asynchronous reconnect loop."""
self.waiting = True
await self.client.start(self.ip)
self.waiting = False
if self.client.protocol is None:
raise IOError("Could not connect to '{}'.".format(self.ip))
self.open = True
async def read_coils(self, address, count):
"""Read a modbus coil."""
return await self._request('read_coils', address, count)
async def read_registers(self, address, count):
"""Read modbus registers.
The Modbus protocol doesn't allow responses longer than 250 bytes
(ie. 125 registers, 62 DF addresses), which this function manages by
chunking larger requests.
"""
registers = []
while count > 124:
r = await self._request('read_holding_registers', address, 124)
registers += r.registers
address, count = address + 124, count - 124
r = await self._request('read_holding_registers', address, count)
registers += r.registers
return registers
async def read_holding_registers(self, address, value):
"""Read modbus holding registers."""
await self._request('read_holding_registers', address, value)
async def write_coil(self, address, value):
"""Write modbus coils."""
await self._request('write_coil', address, value)
async def write_coils(self, address, values):
"""Write modbus coils."""
await self._request('write_coils', address, values)
async def write_register(self, address, value, skip_encode=False):
"""Write a modbus register."""
return await self._request('write_registers',
address,
value,
skip_encode=skip_encode)
async def write_registers(self, address, values, skip_encode=False):
"""Write modbus registers.
The Modbus protocol doesn't allow requests longer than 250 bytes
(ie. 125 registers, 62 DF addresses), which this function manages by
chunking larger requests.
"""
while len(values) > 62:
await self._request('write_registers',
address,
values,
skip_encode=skip_encode)
address, values = address + 124, values[62:]
await self._request('write_registers',
address,
values,
skip_encode=skip_encode)
async def _request(self, method, *args, **kwargs):
"""Send a request to the device and awaits a response.
This mainly ensures that requests are sent serially, as the Modbus
protocol does not allow simultaneous requests (it'll ignore any
request sent while it's processing something). The driver handles this
by assuming there is only one client instance. If other clients
exist, other logic will have to be added to either prevent or manage
race conditions.
"""
while self.waiting:
await asyncio.sleep(0.1)
if self.client.protocol is None or not self.client.protocol.connected:
raise TimeoutError("Not connected to device.")
try:
future = getattr(self.client.protocol, method)(*args, **kwargs)
except AttributeError:
raise TimeoutError("Not connected to device.")
self.waiting = True
try:
return await asyncio.wait_for(future, timeout=self.timeout)
except asyncio.TimeoutError as e:
if self.open:
# This came from reading through the pymodbus@python3 source
# Problem was that the driver was not detecting disconnect
if hasattr(self, 'modbus'):
self.client.protocol_lost_connection(self.modbus)
self.open = False
raise TimeoutError(e)
except pymodbus.exceptions.ConnectionException as e:
raise ConnectionError(e)
finally:
self.waiting = False
def _close(self):
"""Close the TCP connection."""
self.client.stop()
self.open = False
self.waiting = False