pymscada 0.0.15__py3-none-any.whl → 0.1.0__py3-none-any.whl

pymscada/iodrivers/modbus_map.py

@@ -139,7 +139,10 @@ class ModbusMaps():
         """Make the maps."""
         for tagname, v in self.tags.items():
             dtype = v['type']
-            addr = v['addr']
+            try:
+                addr = v['read']
+            except KeyError:
+                addr = v['addr']
             map = ModbusMap(tagname, dtype, addr, self.data, self.value_chg)
             size = DTYPES[dtype][3]
             name, unit, file, word = addr.split(':')

pymscada/iodrivers/modbus_server.py

@@ -37,80 +37,65 @@ class ModbusServerProtocol:
         transport.set_write_buffer_limits(high=0)
         self.transport = transport
 
-    def data_received(self, recv):
-        """Received."""
-        # logging.info(f'received: {recv}')
+    def unpack_mb(self):
+        """Return complete modbus packets and trim the buffer."""
         start = 0
-        self.buffer += recv
         while True:
             buf_len = len(self.buffer)
             if buf_len < 6 + start:  # enough to unpack length
-                self.buffer = self.buffer[start:]
                 break
-            (_mbap_tr, _mbap_pr, mbap_len) = unpack_from(
-                ">3H", self.buffer, start
-            )
-            if buf_len < 6 + mbap_len:  # there is a complete message
-                self.buffer = self.buffer[start:]
+            mbap_tr, mbap_pr, mbap_len = unpack_from(">3H", self.buffer, start)
+            if buf_len < start + 6 + mbap_len:  # there is a complete message
                 break
             end = start + 6 + mbap_len
-            self.msg = self.buffer[start:end]
+            yield self.buffer[start:end]
             start = end
-            self.process()
-            if self.msg is not None:
-                self.transport.write(self.msg)
-            self.msg = b""
+        self.buffer = self.buffer[end:]
+
+    def data_received(self, recv):
+        """Received."""
+        # logging.info(f'received: {recv}')
+        self.buffer += recv
+        for msg in self.unpack_mb():
+            reply = self.process(msg)
+            self.transport.write(reply)
 
     def datagram_received(self, recv, addr):
         """Received."""
-        start = 0
-        buffer = recv
-        while True:
-            buf_len = len(buffer)
-            if buf_len < 6 + start:  # enough to unpack length
-                buffer = buffer[start:]
-                break
-            (_mbap_tr, _mbap_pr, mbap_len) = unpack_from(">3H", buffer, start)
-            if buf_len < 6 + mbap_len:  # there is a complete message
-                buffer = buffer[start:]
-                break
-            end = start + 6 + mbap_len
-            self.msg = buffer[start:end]
-            start = end
-            self.process()
-            if self.msg is not None:
-                self.transport.sendto(self.msg, addr)
-            self.msg = b""
+        self.buffer = recv
+        for msg in self.unpack_mb():
+            reply = self.process(msg)
+            self.transport.sendto(reply, addr)
 
-    def process(self):
+    def process(self, msg):
         """Process."""
         mbap_tr, mbap_pr, _mbap_len, mbap_unit, pdu_fc = unpack_from(
-            ">3H2B", self.msg, 0)
+            ">3H2B", msg, 0)
         if pdu_fc == 3:  # Read Holding Registers
             # Return 0 for missing addresses
-            pdu_start, pdu_count = unpack_from(">2H", self.msg, 8)
+            pdu_start, pdu_count = unpack_from(">2H", msg, 8)
             data = self.mapping.get_data(self.name, mbap_unit, '4x', pdu_start,
                                          pdu_count)
             data_len = len(data)
             msg_len = 3 + data_len
-            self.msg = pack('>3H3B', mbap_tr, mbap_pr, msg_len, mbap_unit,
-                            pdu_fc, data_len) + data
+            reply = pack('>3H3B', mbap_tr, mbap_pr, msg_len, mbap_unit,
+                         pdu_fc, data_len) + data
         elif pdu_fc == 6:  # Set Single Register    4x
-            pdu_start = unpack_from(">H", self.msg, 8)[0]
-            data = bytearray(self.msg[10:12])
+            pdu_start = unpack_from(">H", msg, 8)[0]
+            data = bytearray(msg[10:12])
             self.mapping.set_data(self.name, mbap_unit, '4x', pdu_start,
                                   1, data)
             msg_len = 6
-            self.msg = pack(">3H2BH", mbap_tr, mbap_pr, msg_len, mbap_unit,
-                            pdu_fc, pdu_start) + data
+            reply = pack(">3H2BH", mbap_tr, mbap_pr, msg_len, mbap_unit,
+                         pdu_fc, pdu_start) + data
         elif pdu_fc == 16:  # Set Multiple Registers 4x
-            pdu_start, pdu_count, pdu_bytes = unpack_from(">2HB", self.msg, 8)
-            data = bytearray(self.msg[13:13 + pdu_bytes])
+            pdu_start, pdu_count, pdu_bytes = unpack_from(">2HB", msg, 8)
+            data = bytearray(msg[13:13 + pdu_bytes])
             self.mapping.set_data(self.name, mbap_unit, '4x', pdu_start,
                                   pdu_count, data)
             msg_len = 6
-            self.msg = pack(">3H2B2H", mbap_tr, mbap_pr, msg_len, mbap_unit,
-                            pdu_fc, pdu_start, pdu_count)
+            reply = pack(">3H2B2H", mbap_tr, mbap_pr, msg_len, mbap_unit,
+                         pdu_fc, pdu_start, pdu_count)
         else:
             # Unsupported, send the standard Modbus exception
             logging.warn(
@@ -118,8 +103,9 @@ class ModbusServerProtocol:
                 f" attempted FC {pdu_fc}"
             )
             msg_len = 3
-            self.msg = pack(">3H2BB", mbap_tr, mbap_pr, msg_len, mbap_unit,
-                            pdu_fc + 128, 1)
+            reply = pack(">3H2BB", mbap_tr, mbap_pr, msg_len, mbap_unit,
+                         pdu_fc + 128, 1)
+        return reply
 
 
 class ModbusServerConnector:

pymscada/iodrivers/ping_client.py

@@ -0,0 +1,120 @@
+"""Network monitoring / scanning."""
+import asyncio
+import logging
+import socket
+import struct
+import time
+from pymscada.bus_client import BusClient
+from pymscada.periodic import Periodic
+from pymscada.iodrivers.ping_map import PingMaps
+
+
+ICMP_REQUEST = 8
+ICMP_REPLY = 0
+RATE = 60
+
+
+def checksum_chat(data):
+    """Calculate ICMP Checksum."""
+    if len(data) & 1:  # If the packet length is odd
+        data += b'\0'
+    res = 0
+    # Process two bytes at a time
+    for i in range(0, len(data), 2):
+        res += (data[i] << 8) + data[i + 1]
+    res = (res >> 16) + (res & 0xffff)
+    res += res >> 16
+    return (~res) & 0xffff  # Return ones' complement of the result
+
+
+class PingClientConnector:
+    """Ping a list of addresses."""
+
+    def __init__(self, mapping: PingMaps):
+        """Accept list of addresses, ip or name."""
+        self.mapping = mapping
+        self.dns = {}
+        self.addr_info = {}
+        self.socket = None
+        self.ping_id = 0
+        self.ping_dict = {}
+
+    async def poll(self):
+        """Do pings."""
+        self.reply_dict = {}
+        if self.socket is None:
+            self.socket = socket.socket(socket.AF_INET, socket.SOCK_RAW,
+                                        socket.IPPROTO_ICMP)
+            asyncio.get_event_loop().add_reader(self.socket,
+                                                self.read_response)
+        for ping_id, address in list(self.ping_dict.items()):
+            logging.info(f'failed {self.dns[address]} {ping_id}')
+            self.mapping.polled_data(self.dns[address], float('NAN'))
+            del self.ping_dict[ping_id]
+        self.send_ping()
+
+    def send_ping(self):
+        """Build and send ping messages."""
+        for address in self.dns.keys():
+            self.ping_id = (self.ping_id + 1) & 0xffff
+            self.ping_dict[self.ping_id] = address
+            logging.info(f'ping {address} id {self.ping_id}')
+            header = struct.pack("!BbHHh", ICMP_REQUEST, 0, 0, self.ping_id, 1)
+            data = struct.pack("!d", time.perf_counter()) + (60 * b'\0')
+            checksum = checksum_chat(header + data)
+            packet = struct.pack("!BbHHh", ICMP_REQUEST, 0, checksum,
+                                 self.ping_id, 1) + data
+            self.socket.sendto(packet, (address, 0))
+
+    def read_response(self):
+        """Match ping response."""
+        data, address = self.socket.recvfrom(1024)
+        msgtype, _, _, ping_id, _ = struct.unpack('!BBHHH', data[20:28])
+        if msgtype != ICMP_REPLY:
+            return
+        if ping_id in self.ping_dict:
+            latency = 1000 * (time.perf_counter() -
+                              struct.unpack('!d', data[28:36])[0])
+            name = self.dns[address[0]]
+            logging.info(f'success {name} {ping_id} {latency}ms')
+            self.mapping.polled_data(name, latency)
+            del self.ping_dict[ping_id]
+
+    async def start(self):
+        """Start pinging."""
+        loop = asyncio.get_event_loop()
+        for address in self.mapping.var_map.keys():
+            info = await loop.getaddrinfo(address, None, family=socket.AF_INET,
+                                          type=socket.SOCK_STREAM)
+            ip = info[0][4][0]
+            self.dns[ip] = address
+        self.periodic = Periodic(self.poll, RATE)
+        await self.periodic.start()
+
+
+class PingClient:
+    """Ping client."""
+
+    def __init__(self, bus_ip: str = '127.0.0.1', bus_port: int = 1324,
+                 tags: dict = {}) -> None:
+        """
+        Connect to bus on bus_ip:bus_port, ping a list.
+
+        Event loop must be running.
+        """
+        self.busclient = None
+        if bus_ip is not None:
+            self.busclient = BusClient(bus_ip, bus_port)
+        self.mapping = PingMaps(tags)
+        self.pinger = PingClientConnector(mapping=self.mapping)
+
+    async def _poll(self):
+        """For testing."""
+        for connection in self.connections:
+            await connection.poll()
+
+    async def start(self):
+        """Start bus connection and PLC polling."""
+        if self.busclient is not None:
+            await self.busclient.start()
+        await self.pinger.start()

pymscada/iodrivers/ping_map.py

@@ -0,0 +1,43 @@
+"""Map between snmp MIB and Tag."""
+from time import time
+from pymscada.tag import Tag
+
+
+class PingMap:
+    """Do value updates for each tag."""
+
+    def __init__(self, tagname: str, addr: str):
+        """Initialise MIB map and Tag."""
+        self.last_value = None
+        self.tag = Tag(tagname, float)
+        self.addr = addr
+        self.map_bus = id(self)
+
+    def set_tag_value(self, value, time_us):
+        """Pass update from IO driver to tag value."""
+        if self.last_value is None:
+            self.last_value = value
+            return
+        if self.last_value != value:
+            self.tag.value = value, time_us, self.map_bus
+
+
+class PingMaps:
+    """Link tags with protocol connector."""
+
+    def __init__(self, tags: dict):
+        """Collect maps based on a tag dictionary."""
+        # use the tagname to access the map.
+        self.tag_map: dict[str, PingMap] = {}
+        # use the plc_name then variable name to access a list of maps.
+        self.var_map: dict[str, PingMap] = {}
+        for tagname, v in tags.items():
+            addr = v['addr']
+            map = PingMap(tagname, addr)
+            self.var_map[addr] = map
+            self.tag_map[tagname] = map
+
+    def polled_data(self, address, latency):
+        """Pass updates read from the PLC to the tags."""
+        time_us = int(time() * 1e6)
+        self.var_map[address].set_tag_value(latency, time_us)

pymscada/iodrivers/snmp_client.py

@@ -1,3 +1,4 @@
+"""Poll SNMP OIDs from devices."""
 import logging
 import pysnmp.hlapi.asyncio as snmp
 from pymscada.bus_client import BusClient
@@ -8,14 +9,14 @@ from pymscada.iodrivers.snmp_map import SnmpMaps
 class SnmpClientConnector:
     """Poll snmp devices, write and traps are not implemented."""
 
-    def __init__(self, name: str, ip:str, rate: float, read: list,
+    def __init__(self, name: str, ip: str, rate: float, poll: list,
                  community: str, mapping: SnmpMaps):
         """Set up polling client."""
         self.snmp_name = name
         self.ip = ip
         self.community = community
         self.read_oids = [snmp.ObjectType(snmp.ObjectIdentity(x))
-                          for x in read]
+                          for x in poll]
         self.mapping = mapping
         self.periodic = Periodic(self.poll, rate)
         self.snmp_engine = snmp.SnmpEngine()
@@ -45,6 +46,7 @@ class SnmpClientConnector:
 
 
 class SnmpClient:
+    """SNMP client."""
 
     def __init__(self, bus_ip: str = '127.0.0.1', bus_port: int = 1324,
                  rtus: dict = {}, tags: dict = {}) -> None:

pymscada/iodrivers/snmp_map.py

@@ -52,7 +52,7 @@ class SnmpMaps:
         # use the plc_name then variable name to access a list of maps.
         self.var_map: dict[str, dict[str, list[SnmpMap]]] = {}
         for tagname, v in tags.items():
-            addr = v['addr']
+            addr = v['read']
             map = SnmpMap(tagname, v['type'], addr)
             if map.plc not in self.var_map:
                 self.var_map[map.plc] = {}

pymscada/main.py

@@ -1,7 +1,9 @@
 """Main server entry point."""
 import argparse
 import asyncio
+from importlib.metadata import version
 import logging
+import sys
 from pymscada.bus_server import BusServer
 from pymscada.checkout import checkout
 from pymscada.config import Config
@@ -11,92 +13,258 @@ from pymscada.history import History
 from pymscada.iodrivers.logix_client import LogixClient
 from pymscada.iodrivers.modbus_client import ModbusClient
 from pymscada.iodrivers.modbus_server import ModbusServer
+from pymscada.iodrivers.ping_client import PingClient
 from pymscada.iodrivers.snmp_client import SnmpClient
-from pymscada.simulate import Simulate
 from pymscada.www_server import WwwServer
 from pymscada.validate import validate
 
 
-def args():
-    """Read commandline arguments."""
-    parser = argparse.ArgumentParser(
-        prog='pymscada',
-        description='Connect IO, logic, applications and webpage UI.',
-        epilog='Python MobileSCADA.'
-    )
-    commands = ['bus', 'console', 'wwwserver', 'history', 'files',
-                'logixclient',
-                'modbusserver', 'modbusclient',
-                'snmpclient',
-                'simulate', 'checkout',
-                'validate']
-    parser.add_argument('module', type=str, choices=commands, metavar='action',
-                        help=f'select one of: {", ".join(commands)}')
-    parser.add_argument('--config', metavar='file',
-                        help='Config file, default is "[module].yaml".')
-    parser.add_argument('--tags', metavar='file',
-                        help='Tags file, default is "tags.yaml".')
-    parser.add_argument('--verbose', action='store_true',
-                        help="Set level to logging.INFO.")
-    parser.add_argument('--path', metavar='folder',
-                        help="Working folder, used for history and validate.")
-    parser.add_argument('--overwrite', action='store_true', default=False,
-                        help='checkout may overwrite files, CARE!')
-    return parser.parse_args()
+class Module():
+    """Default Module."""
 
+    name = None
+    help = None
+    epilog = None
+    module = None
+    config = True
+    tags = True
+    sub = None
 
-async def run():
-    """Run bus and wwwserver."""
-    options = args()
-    if options.verbose:
-        logging.basicConfig(level=logging.INFO)
-    if options.config is None:
-        options.config = f'{options.module}.yaml'
-    if options.tags is None:
-        options.tags = 'tags.yaml'
-    if options.module == 'bus':
+    def __init__(self, subparser: argparse._SubParsersAction):
+        """Add arguments common to all subparsers."""
+        self.sub = subparser.add_parser(
+            self.name, help=self.help, epilog=self.epilog)
+        self.sub.set_defaults(app=self)
+        if self.config:
+            self.sub.add_argument(
+                '--config', metavar='file', default=f'{self.name}.yaml',
+                help=f"Config file, default is '{self.name}.yaml'")
+        if self.tags:
+            self.sub.add_argument(
+                '--tags', metavar='file', default='tags.yaml',
+                help="Tags file, default is 'tags.yaml'")
+        self.sub.add_argument('--verbose', action='store_true',
+                              help="Set level to logging.INFO")
+
+
+class _Bus(Module):
+    """Bus Server."""
+
+    name = 'bus'
+    help = 'run the message bus'
+    tags = False
+
+    def run_once(self, options):
+        """Create the module."""
         config = Config(options.config)
-        module = BusServer(**config)
-    elif options.module == 'console':
-        module = Console()
-    elif options.module == 'wwwserver':
+        self.module = BusServer(**config)
+
+
+class _WwwServer(Module):
+    """WWW Server Module."""
+
+    name = 'wwwserver'
+    help = 'serve web pages'
+
+    def run_once(self, options):
+        """Create the module."""
         config = Config(options.config)
         tag_info = dict(Config(options.tags))
-        module = WwwServer(tag_info=tag_info, **config)
-    elif options.module == 'history':
+        self.module = WwwServer(tag_info=tag_info, **config)
+
+
+class _History(Module):
+    """History Module."""
+
+    name = 'history'
+    help = 'collect and serve history'
+
+    def run_once(self, options):
+        """Create the module."""
         config = Config(options.config)
         tag_info = dict(Config(options.tags))
-        module = History(tag_info=tag_info, **config)
-    elif options.module == 'files':
+        self.module = History(tag_info=tag_info, **config)
+
+
+class _Files(Module):
+    """Bus Module."""
+
+    name = 'files'
+    help = 'receive and send files'
+    tags = False
+
+    def run_once(self, options):
+        """Create the module."""
         config = Config(options.config)
-        module = Files(**config)
-    elif options.module == 'logixclient':
+        self.module = Files(**config)
+
+
+class _Console(Module):
+    """Bus Module."""
+
+    name = 'console'
+    help = 'interactive bus console'
+    config = False
+    tags = False
+
+    def run_once(self, _options):
+        """Create the module."""
+        self.module = Console()
+
+
+class _checkout(Module):
+    """Bus Module."""
+
+    name = 'checkout'
+    help = 'create example config files'
+    epilog = """
+        To add to systemd `f="pymscada-bus" && cp config/$f.service
+        /lib/systemd/system && systemctl enable $f && systemctl start
+        $f`"""
+    config = False
+    tags = False
+
+    def __init__(self, subparser: argparse._SubParsersAction):
+        super().__init__(subparser)
+        self.sub.add_argument(
+            '--overwrite', action='store_true', default=False,
+            help='checkout may overwrite files, CARE!')
+        self.sub.add_argument(
+            '--diff', action='store_true', default=False,
+            help='compare default with existing')
+
+    def run_once(self, options):
+        """Create the module."""
+        checkout(overwrite=options.overwrite, diff=options.diff)
+
+
+class _validate(Module):
+    """Bus Module."""
+
+    name = 'validate'
+    help = 'validate config files'
+    config = False
+    tags = False
+
+    def __init__(self, subparser: argparse._SubParsersAction):
+        super().__init__(subparser)
+        self.sub.add_argument(
+            '--path', metavar='file',
+            help='default is current working directory')
+
+    def run_once(self, options):
+        """Create the module."""
+        r, e, p = validate(options.path)
+        if r:
+            print(f'Config files in {p} valid.')
+        else:
+            print(e)
+
+
+class _ModbusServer(Module):
+    """Bus Module."""
+
+    name = 'modbusserver'
+    help = 'receive modbus messages'
+    epilog = """
+        Needs `setcap CAP_NET_BIND_SERVICE=+eip /usr/bin/python3.nn` to
+        bind to port 502."""
+    tags = False
+
+    def run_once(self, options):
+        """Create the module."""
         config = Config(options.config)
-        module = LogixClient(**config)
-    elif options.module == 'modbusclient':
+        self.module = ModbusServer(**config)
+
+
+class _ModbusClient(Module):
+    """Bus Module."""
+
+    name = 'modbusclient'
+    help = 'poll/write to modbus devices'
+    tags = False
+
+    def run_once(self, options):
+        """Create the module."""
         config = Config(options.config)
-        module = ModbusClient(**config)
-    elif options.module == 'modbusserver':
+        self.module = ModbusClient(**config)
+
+
+class _LogixClient(Module):
+    """Bus Module."""
+
+    name = 'logixclient'
+    help = 'poll/write to logix devices'
+
+    def run_once(self, options):
+        """Create the module."""
         config = Config(options.config)
-        module = ModbusServer(**config)
-    elif options.module == 'snmpclient':
+        self.module = LogixClient(**config)
+
+
+class _PingClient(Module):
+    """Bus Module."""
+
+    name = 'ping'
+    help = 'ping a list of addresses, return time'
+    epilog = """
+        Needs `setcap CAP_NET_RAW+ep /usr/bin/python3.nn` to open SOCK_RAW
+    """
+    tags = False
+
+    def run_once(self, options):
+        """Create the module."""
+        if sys.platform.startswith("win"):
+            asyncio.set_event_loop_policy(
+                asyncio.WindowsSelectorEventLoopPolicy())
         config = Config(options.config)
-        module = SnmpClient(**config)
-    elif options.module == 'simulate':
+        self.module = PingClient(**config)
+
+
+class _SnmpClient(Module):
+    """Bus Module."""
+
+    name = 'snmpclient'
+    help = 'poll snmp oids'
+    tags = False
+
+    def run_once(self, options):
+        """Create the module."""
         config = Config(options.config)
-        tag_info = dict(Config(options.tags))
-        module = Simulate(tag_info=tag_info, **config)
-    elif options.module == 'checkout':
-        checkout(overwrite=options.overwrite)
-        return
-    elif options.module == 'validate':
-        r, e = validate(options.path)
-        if r == True:
-            print(f'Config files in {options.path} valid.')
-        else:
-            print(e)
-        return
-    else:
-        logging.warning(f'no {options.module}')
-    await module.start()
-    await asyncio.get_event_loop().create_future()
+        self.module = SnmpClient(**config)
+
+
+def args(_version: str):
+    """Read commandline arguments."""
+    parser = argparse.ArgumentParser(
+        prog='pymscada',
+        description='Connect IO, logic, applications, and webpage UI',
+        epilog=f'Python Mobile SCADA {_version}'
+    )
+    s = parser.add_subparsers(title='module')
+    _Bus(s)
+    _WwwServer(s)
+    _History(s)
+    _Files(s)
+    _Console(s)
+    _checkout(s)
+    _validate(s)
+    _ModbusServer(s)
+    _ModbusClient(s)
+    _LogixClient(s)
+    _SnmpClient(s)
+    _PingClient(s)
+    return parser.parse_args()
+
+
+async def run():
+    """Run bus and wwwserver."""
+    _version = version("pymscada")
+    logging.warning(f'pymscada {_version} starting')
+    options = args(_version)
+    if options.verbose:
+        logging.getLogger().setLevel(logging.INFO)
+    options.app.run_once(options)
+    if options.app.module is not None:
+        await options.app.module.start()
+        await asyncio.get_event_loop().create_future()