pymscada 0.1.0a5__py3-none-any.whl → 0.1.1a2__py3-none-any.whl

pymscada/iodrivers/modbus_server.py

@@ -161,7 +161,8 @@ class ModbusServer:
         """
         self.busclient = None
         if bus_ip is not None:
-            self.busclient = BusClient(bus_ip, bus_port)
+            self.busclient = BusClient(bus_ip, bus_port,
+                                       module='Modbus Server')
         self.mapping = ModbusMaps(tags)
         self.connections: list[ModbusServerConnector] = []
         for rtu in rtus:

pymscada/iodrivers/ping_client.py

@@ -104,7 +104,7 @@ class PingClient:
         """
         self.busclient = None
         if bus_ip is not None:
-            self.busclient = BusClient(bus_ip, bus_port)
+            self.busclient = BusClient(bus_ip, bus_port, module='Ping Client')
         self.mapping = PingMaps(tags)
         self.pinger = PingClientConnector(mapping=self.mapping)
 

pymscada/iodrivers/snmp_client.py

@@ -9,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()
@@ -57,7 +57,7 @@ class SnmpClient:
         """
         self.busclient = None
         if bus_ip is not None:
-            self.busclient = BusClient(bus_ip, bus_port)
+            self.busclient = BusClient(bus_ip, bus_port, module='SNMP Client')
         self.mapping = SnmpMaps(tags)
         self.connections: list[SnmpClientConnector] = []
         for rtu in rtus:

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

@@ -10,110 +10,253 @@ from pymscada.config import Config
 from pymscada.console import Console
 from pymscada.files import Files
 from pymscada.history import History
+from pymscada.opnotes import OpNotes
+from pymscada.www_server import WwwServer
 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.www_server import WwwServer
 from pymscada.validate import validate
 
 
-MODULES = {}
+class Module():
+    """Default Module."""
+
+    name = None
+    help = None
+    epilog = None
+    module = None
+    config = True
+    tags = True
+    sub = None
+    await_future = True
+
+    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)
+        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))
+        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))
+        self.module = History(tag_info=tag_info, **config)
+
+
+class _Files(Module):
+    """Files Module."""
+
+    name = 'files'
+    help = 'receive and send files'
+    tags = False
+
+    def run_once(self, options):
+        """Create the module."""
+        config = Config(options.config)
+        self.module = Files(**config)
+
+
+class _OpNotes(Module):
+    """Operator Notes Module."""
+
+    name = 'opnotes'
+    help = 'present and manage operator notes'
+    tags = False
+
+    def run_once(self, options):
+        """Create the module."""
+        config = Config(options.config)
+        self.module = OpNotes(**config)
+
+
+class _Console(Module):
+    """Bus Module."""
+
+    name = 'console'
+    help = 'interactive bus console'
+    config = False
+    await_future = False
+
+    def __init__(self, subparser: argparse._SubParsersAction):
+        super().__init__(subparser)
+        self.sub.add_argument(
+            '-p', '--port', action='store', type=int, default=1324,
+            help='connect to port (default: 1324)')
+        self.sub.add_argument(
+            '-i', '--ip', action='store', default='localhost',
+            help='connect to ip address (default: locahost)')
+
+    def run_once(self, options):
+        """Create the module."""
+        tag_info = dict(Config(options.tags))
+        self.module = Console(options.ip, options.port, tag_info)
+
+
+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)
 
-async def bus(options):
-    """Return bus module."""
-    config = Config(options.config)
-    return BusServer(**config)
 
+class _validate(Module):
+    """Bus Module."""
 
-async def wwwserver(options):
-    """Return wwwserver module."""
-    config = Config(options.config)
-    tag_info = dict(Config(options.tags))
-    return WwwServer(tag_info=tag_info, **config)
+    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')
 
-async def history(options):
-    """Return history module."""
-    config = Config(options.config)
-    tag_info = dict(Config(options.tags))
-    return History(tag_info=tag_info, **config)
+    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)
 
 
-async def files(options):
-    """TODO Return files module."""
-    config = Config(options.config)
-    return Files(**config)
+class _LogixClient(Module):
+    """Bus Module."""
 
+    name = 'logixclient'
+    help = 'poll/write to logix devices'
 
-async def console(_options):
-    """TODO Return console module."""
-    return Console()
+    def run_once(self, options):
+        """Create the module."""
+        config = Config(options.config)
+        self.module = LogixClient(**config)
 
 
-async def _checkout(options):
-    """Checkout files in current working directory."""
-    checkout(overwrite=options.overwrite, diff=options.diff)
-    return
+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
 
-async def _validate(options):
-    """Validate config files."""
-    r, e, p = validate(options.path)
-    if r:
-        print(f'Config files in {p} valid.')
-    else:
-        print(e)
-    return
+    def run_once(self, options):
+        """Create the module."""
+        config = Config(options.config)
+        self.module = ModbusServer(**config)
 
 
-async def modbusserver(options):
-    """Return modbusserver module."""
-    config = Config(options.config)
-    return ModbusServer(**config)
+class _ModbusClient(Module):
+    """Bus Module."""
 
+    name = 'modbusclient'
+    help = 'poll/write to modbus devices'
+    tags = False
 
-async def modbusclient(options):
-    """Return modbusclient module."""
-    config = Config(options.config)
-    return ModbusClient(**config)
+    def run_once(self, options):
+        """Create the module."""
+        config = Config(options.config)
+        self.module = ModbusClient(**config)
 
 
-async def logixclient(options):
-    """Return logixclient module."""
-    config = Config(options.config)
-    return 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
 
-async def ping(options):
-    """Return logixclient module."""
-    if sys.platform.startswith("win"):
-        asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
-    config = Config(options.config)
-    return PingClient(**config)
+    def run_once(self, options):
+        """Create the module."""
+        if sys.platform.startswith("win"):
+            asyncio.set_event_loop_policy(
+                asyncio.WindowsSelectorEventLoopPolicy())
+        config = Config(options.config)
+        self.module = PingClient(**config)
 
 
-async def snmpclient(options):
-    """Return snmpclient module."""
-    config = Config(options.config)
-    return SnmpClient(**config)
+class _SnmpClient(Module):
+    """Bus Module."""
 
+    name = 'snmpclient'
+    help = 'poll snmp oids'
+    tags = False
 
-def add_subparser_defaults(
-        parser: argparse._SubParsersAction,
-        name: str, call, help: str, epilog: str):
-    """Add arguments common to all subparsers."""
-    s = parser.add_parser(name, help=help, epilog=epilog)
-    s.set_defaults(get_module=call, module=name)
-    s.add_argument('--config', metavar='file', default=None,
-                   help=f"Config file, default is '{name}.yaml'")
-    s.add_argument('--tags', metavar='file', default=None,
-                   help="Tags file, default is 'tags.yaml'")
-    s.add_argument('--verbose', action='store_true',
-                   help="Set level to logging.INFO")
-    return s
+    def run_once(self, options):
+        """Create the module."""
+        config = Config(options.config)
+        self.module = SnmpClient(**config)
 
 
 def args(_version: str):
@@ -123,41 +266,20 @@ def args(_version: str):
         description='Connect IO, logic, applications, and webpage UI',
         epilog=f'Python Mobile SCADA {_version}'
     )
-    subparsers = parser.add_subparsers(title='module')
-    for module, func, help, epilog in [
-        ['bus', bus, 'run the message bus', None],
-        ['wwwserver', wwwserver, 'serve web pages', None],
-        ['history', history, 'collect and serve history', None],
-        ['files', files, 'receive and send files', None],
-        ['console', console, 'interactive bus console', None],
-        ['checkout', _checkout, 'create example config files', """
-            To add to systemd `f="pymscada-bus" && cp config/$f.service
-            /lib/systemd/system && systemctl enable $f && systemctl start
-            $f`"""],
-        ['validate', _validate, 'validate config files', None],
-        ['modbusserver', modbusserver, 'receive modbus messages', """
-            Needs `setcap CAP_NET_BIND_SERVICE=+eip /usr/bin/python3.nn` to
-            bind to port 502"""],
-        ['modbusclient', modbusclient, 'poll/write to modbus devices', None],
-        ['ping', ping, 'ping a list of addresses, return time', """
-            Needs `setcap CAP_NET_RAW+ep /usr/bin/python3.nn` to open SOCK_RAW
-            """],
-        ['logixclient', logixclient, 'poll/write to logix devices', None],
-        ['snmpclient', snmpclient, 'poll snmp oids', None],
-    ]:
-        modparser = add_subparser_defaults(subparsers, module, func, help,
-                                           epilog)
-        if module == 'checkout':
-            modparser.add_argument(
-                '--overwrite', action='store_true', default=False,
-                help='checkout may overwrite files, CARE!')
-            modparser.add_argument(
-                '--diff', action='store_true', default=False,
-                help='compare default with existing')
-        elif module == 'validate':
-            modparser.add_argument(
-                '--path', metavar='file',
-                help='default is current working directory')
+    s = parser.add_subparsers(title='module')
+    _Bus(s)
+    _WwwServer(s)
+    _History(s)
+    _Files(s)
+    _OpNotes(s)
+    _Console(s)
+    _checkout(s)
+    _validate(s)
+    _LogixClient(s)
+    _ModbusServer(s)
+    _ModbusClient(s)
+    _PingClient(s)
+    _SnmpClient(s)
     return parser.parse_args()
 
 
@@ -167,13 +289,9 @@ async def run():
     logging.warning(f'pymscada {_version} starting')
     options = args(_version)
     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'
-    module = await options.get_module(options)
-    if module is None:
-        return
-    await module.start()
-    await asyncio.get_event_loop().create_future()
+        logging.getLogger().setLevel(logging.INFO)
+    options.app.run_once(options)
+    if options.app.module is not None:
+        await options.app.module.start()
+        if options.app.await_future:
+            await asyncio.get_event_loop().create_future()

pymscada/opnotes.py

@@ -0,0 +1,108 @@
+"""Operator Notes."""
+import logging
+import sqlite3  # note that sqlite3 has blocking calls
+from pymscada.bus_client import BusClient
+from pymscada.tag import Tag
+
+
+class OpNotes:
+    """Connect to bus_ip:bus_port, store and provide Operator Notes."""
+
+    def __init__(self, bus_ip: str = '127.0.0.1', bus_port: int = 1324,
+                 db: str = None, rta_tag: str = '__opnotes__',
+                 table: str = 'opnotes') -> None:
+        """
+        Connect to bus_ip:bus_port, serve and update operator notes database.
+
+        TODO
+        Write something.
+
+        Event loop must be running.
+        """
+        if db is None:
+            raise SystemExit('OpNotes db must be defined')
+        logging.warning(f'OpNotes {bus_ip} {bus_port} {db} {rta_tag}')
+        self.connection = sqlite3.connect(db)
+        self.table = table
+        self.cursor = self.connection.cursor()
+        query = (
+            'CREATE TABLE IF NOT EXISTS ' + self.table +
+            '(oid INTEGER PRIMARY KEY ASC, '
+            'datetime INTEGER, '
+            'site TEXT, '
+            'operator TEXT, '
+            'note TEXT)'
+        )
+        self.cursor.execute(query)
+        self.busclient = BusClient(bus_ip, bus_port, module='OpNotes')
+        self.rta = Tag(rta_tag, dict)
+        self.busclient.add_callback_rta(rta_tag, self.rta_cb)
+
+    def rta_cb(self, request):
+        """Respond to Request to Author and publish on rta_tag as needed."""
+        if 'action' not in request:
+            logging.warning(f'rta_cb malformed {request}')
+        elif request['action'] == 'ADD':
+            try:
+                with self.connection:
+                    self.cursor.execute(
+                        f'INSERT INTO {self.table} (datetime, site, operator, '
+                        'note) VALUES(:datetime, :site, :operator, :note) '
+                        'RETURNING *;',
+                        request)
+                    res = self.cursor.fetchone()
+                    self.rta.value = {
+                        'oid': res[0],
+                        'datetime': res[1],
+                        'site': res[2],
+                        'operator': res[3],
+                        'note': res[4]
+                    }
+            except sqlite3.IntegrityError as error:
+                logging.warning(f'OpNotes rta_cb {error}')
+        elif request['action'] == 'MODIFY':
+            try:
+                with self.connection:
+                    self.cursor.execute(
+                        f'REPLACE INTO {self.table} VALUES(:oid, :datetime, '
+                        ':site, :operator, :note) RETURNING *;', request)
+                    res = self.cursor.fetchone()
+                    self.rta.value = {
+                        'oid': res[0],
+                        'datetime': res[1],
+                        'site': res[2],
+                        'operator': res[3],
+                        'note': res[4]
+                    }
+            except sqlite3.IntegrityError as error:
+                logging.warning(f'OpNotes rta_cb {error}')
+        elif request['action'] == 'DELETE':
+            try:
+                with self.connection:
+                    self.cursor.execute(
+                        f'DELETE FROM {self.table} WHERE oid = :oid;', request)
+                    self.rta.value = {'oid': request['oid']}
+            except sqlite3.IntegrityError as error:
+                logging.warning(f'OpNotes rta_cb {error}')
+        elif request['action'] == 'HISTORY':
+            tag = Tag(request['reply_tag'], dict)
+            try:
+                with self.connection:
+                    self.cursor.execute(
+                        f'SELECT * FROM {self.table} WHERE datetime < '
+                        ':datetime ORDER BY ABS(datetime - :datetime) '
+                        'LIMIT 2;', request)
+                    for res in self.cursor.fetchall():
+                        tag.value = {
+                            'oid': res[0],
+                            'datetime': res[1],
+                            'site': res[2],
+                            'operator': res[3],
+                            'note': res[4]
+                        }
+            except sqlite3.IntegrityError as error:
+                logging.warning(f'OpNotes rta_cb {error}')
+
+    async def start(self):
+        """Async startup."""
+        await self.busclient.start()

pymscada/protocol_constants.py

@@ -3,12 +3,12 @@ Protocol description and protocol constants.
 
 Bus holds a tag forever, assigns a tag id forever, holds a tag value with len
 < 1000 forever, otherwise wipes periodically. So assign tagnames once, at the
-start of your program; use RQS as an update messenger, share whole structures
+start of your program; use RTA as an update messenger, share whole structures
 rarely.
 
 - version 16-bit unsigned int == 0x01
 - command 16-bit unsigned int
-- tag_id 32-bit unsigned int
+- tag_id 32-bit unsigned int     0 is not a valid tag_id
 - size 32-bit unsigned int
   - if size == 0xff  continuation mandatory
   - size 0x00 completes an empty continuation
@@ -23,7 +23,7 @@ command
 - CMD_UNSUB id
   - no reply
 - CMD_GET id
-- CMD_RQS id, data is request to tag creator
+- CMD_RTA id, data is request to author
 - CMD_SUB id
   - reply: SET id and value, value may be None
 - CMD_LIST
@@ -34,6 +34,7 @@ command
     - text$ matches start of tagname
     - text matches anywhere in tagname
   - reply: LIST data as space separated tagnames
+- CMD_LOG data to logging.warning
 """
 
 # Tuning constants
@@ -43,25 +44,27 @@ MAX_LEN = 65535 - 14  # TODO fix server(?) when 3
 CMD_ID = 1  # query / inform tag ID - data is tagname bytes string
 CMD_SET = 2  # set a tag
 CMD_GET = 3  # get a tag
-CMD_RQS = 4  # request set - request passed to last tag setter
+CMD_RTA = 4  # request to author
 CMD_SUB = 5  # subscribe to a tag
 CMD_UNSUB = 6  # unsubscribe from a tag
 CMD_LIST = 7  # bus list tags
 CMD_ERR = 8  # action failed
+CMD_LOG = 9  # bus print a logging message
 
 CMD_TEXT = {
     1: 'CMD_ID',
     2: 'CMD_SET',
     3: 'CMD_GET',
-    4: 'CMD_RQS',
+    4: 'CMD_RTA',
     5: 'CMD_SUB',
     6: 'CMD_UNSUB',
     7: 'CMD_LIST',
-    8: 'CMD_ERR'
+    8: 'CMD_ERR',
+    9: 'CMD_LOG'
 }
 
-COMMANDS = [CMD_ID, CMD_SET, CMD_GET, CMD_RQS, CMD_SUB, CMD_UNSUB, CMD_LIST,
-            CMD_ERR]
+COMMANDS = [CMD_ID, CMD_SET, CMD_GET, CMD_RTA, CMD_SUB, CMD_UNSUB, CMD_LIST,
+            CMD_ERR, CMD_LOG]
 
 # data types
 TYPE_INT = 1  # 64 bit signed integer

pymscada/tag.py

@@ -18,6 +18,28 @@ TYPES = {
 }
 
 
+def tag_for_web(tagname: str, tag: dict):
+    """Correct tag dictionary in place to be suitable for web client."""
+    tag['name'] = tagname
+    tag['id'] = None
+    if 'desc' not in tag:
+        tag['desc'] = tag.name
+    if 'multi' in tag:
+        tag['type'] = 'int'
+    else:
+        if 'type' not in tag:
+            tag['type'] = 'float'
+        else:
+            if tag['type'] not in TYPES:
+                tag['type'] = 'str'
+    if tag['type'] == 'int':
+        tag['dp'] = 0
+    elif tag['type'] == 'float' and 'dp' not in tag:
+        tag['dp'] = 2
+    elif tag['type'] == 'str' and 'dp' in tag:
+        del tag['dp']
+
+
 class UniqueTag(type):
     """Super Tag class only create unique tags for unique tag names."""