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

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()

pymscada/validate.py

@@ -51,7 +51,7 @@ TAG_SCHEMA = {
     'keysrules': {
         'type': 'string',
         # tag name discovery, save for later checking
-        'ms_tagname': True
+        'ms_tagname': 'save'
     },
     'valuesrules': {
         'type': 'dict',
@@ -67,7 +67,7 @@ TAG_SCHEMA = {
 BUS_SCHEMA = {
     'type': 'dict',
     'schema': {
-        'ip': {'type': 'string', 'ms_ip': True},
+        'ip': {'type': 'string', 'ms_ip': 'ipv4 none'},
         'port': {'type': 'integer', 'min': 1024, 'max': 65536}
     }
 }
@@ -88,12 +88,12 @@ VALUESETFILES_LIST = {
         'allowed': ['value', 'setpoint', 'files'],
     },
     # tagname must have been found in parsing tags.yaml
-    'tagname': {'type': 'string', 'ms_tagname': False}
+    'tagname': {'type': 'string', 'ms_tagname': 'exists'}
 }
 SELECTDICT_LIST = {
     'type': {'type': 'string', 'allowed': ['selectdict']},
     # tagname must have been found in parsing tags.yaml
-    'tagname': {'type': 'string', 'ms_tagname': False},
+    'tagname': {'type': 'string', 'ms_tagname': 'exists'},
     'opts': {
         'type': 'dict',
         # 'schema': {
@@ -138,7 +138,7 @@ UPLOT_LIST = {
             'type': 'dict',
             'schema': {
                 # tagname must have been found in parsing tags.yaml
-                'tagname': {'type': 'string', 'ms_tagname': False},
+                'tagname': {'type': 'string', 'ms_tagname': 'exists'},
                 'label': {'type': 'string', 'required': False},
                 'scale': {'type': 'string', 'required': False},
                 'color': {'type': 'string', 'required': False},
@@ -170,9 +170,9 @@ LIST_WWWSERVER = {
 WWWSERVER_SCHEMA = {
     'type': 'dict',
     'schema': {
-        'bus_ip': {'type': 'string', 'ms_ip': True},
+        'bus_ip': {'type': 'string', 'ms_ip': 'none ipv4'},
         'bus_port': {'type': 'integer', 'min': 1024, 'max': 65536},
-        'ip': {'type': 'string', 'ms_ip': True},
+        'ip': {'type': 'string', 'ms_ip': 'none ipv4'},
         'port': {'type': 'integer', 'min': 1024, 'max': 65536},
         'get_path': {'nullable': True},
         'paths': {'type': 'list', 'allowed': ['history', 'config', 'pdf']},
@@ -186,7 +186,7 @@ WWWSERVER_SCHEMA = {
 HISTORY_SCHEMA = {
     'type': 'dict',
     'schema': {
-        'bus_ip': {'type': 'string', 'ms_ip': True},
+        'bus_ip': {'type': 'string', 'ms_ip': 'none ipv4'},
         'bus_port': {'type': 'integer', 'min': 1024, 'max': 65536},
         'path': {'type': 'string'},
     }
@@ -195,7 +195,7 @@ HISTORY_SCHEMA = {
 MODBUSSERVER_SCHEMA = {
     'type': 'dict',
     'schema': {
-        'bus_ip': {'type': 'string', 'ms_ip': True, 'nullable': True},
+        'bus_ip': {'type': 'string', 'ms_ip': 'none ipv4', 'nullable': True},
         'bus_port': {'type': 'integer', 'min': 1024, 'max': 65536,
                      'nullable': True},
         'path': {'type': 'string'},
@@ -219,7 +219,7 @@ MODBUSSERVER_SCHEMA = {
             'type': 'dict',
             'keysrules': {
                 'type': 'string',
-                'ms_tagname': False
+                'ms_tagname': 'none'
             },
             'valuesrules': {
                 'type': 'dict',
@@ -235,7 +235,7 @@ MODBUSSERVER_SCHEMA = {
 MODBUSCLIENT_SCHEMA = {
     'type': 'dict',
     'schema': {
-        'bus_ip': {'type': 'string', 'ms_ip': True, 'nullable': True},
+        'bus_ip': {'type': 'string', 'ms_ip': 'ipv4'},
         'bus_port': {'type': 'integer', 'min': 1024, 'max': 65536,
                      'nullable': True},
         'path': {'type': 'string'},
@@ -249,11 +249,48 @@ MODBUSCLIENT_SCHEMA = {
                     'port': {},
                     'tcp_udp': {'type': 'string', 'allowed': ['tcp', 'udp']},
                     'rate': {},
-                    'read': {
+                    'poll': {
                         'type': 'list',
                         'schema': {}
-                    },
-                    'writeok': {
+                    }
+                }
+            }
+        },
+        'tags': {
+            'type': 'dict',
+            'keysrules': {
+                'type': 'string',
+                'ms_tagname': 'exists'
+            },
+            'valuesrules': {
+                'type': 'dict',
+                'schema': {
+                    'type': {},
+                    'read': {},
+                    'write': {}
+                }
+            }
+        }
+    }
+}
+
+SNMPCLIENT_SCHEMA = {
+    'type': 'dict',
+    'schema': {
+        'bus_ip': {'type': 'string', 'ms_ip': 'ipv4'},
+        'bus_port': {'type': 'integer', 'min': 1024, 'max': 65536,
+                     'nullable': True},
+        'path': {'type': 'string'},
+        'rtus': {
+            'type': 'list',
+            'schema': {
+                'type': 'dict',
+                'schema': {
+                    'name': {},
+                    'ip': {},
+                    'community': {},
+                    'rate': {},
+                    'poll': {
                         'type': 'list',
                         'schema': {}
                     }
@@ -264,44 +301,91 @@ MODBUSCLIENT_SCHEMA = {
             'type': 'dict',
             'keysrules': {
                 'type': 'string',
-                'ms_tagname': False
+                'ms_tagname': 'exists'
             },
             'valuesrules': {
                 'type': 'dict',
                 'schema': {
                     'type': {},
-                    'addr': {}
-                },
+                    'read': {}
+                }
             }
-        }           
+        }
     }
 }
 
+LOGIXCLIENT_SCHEMA = {
+    'type': 'dict',
+    'schema': {
+        'bus_ip': {'type': 'string', 'ms_ip': 'ipv4'},
+        'bus_port': {'type': 'integer', 'min': 1024, 'max': 65536,
+                     'nullable': True},
+        'path': {'type': 'string'},
+        'rtus': {
+            'type': 'list',
+            'schema': {
+                'type': 'dict',
+                'schema': {
+                    'name': {},
+                    'ip': {},
+                    'rate': {},
+                    'poll': {
+                        'type': 'list',
+                        'schema': {}
+                    }
+                }
+            }
+        },
+        'tags': {
+            'type': 'dict',
+            'keysrules': {
+                'type': 'string',
+                'ms_tagname': 'exists'
+            },
+            'valuesrules': {
+                'type': 'dict',
+                'schema': {
+                    'type': {},
+                    'read': {},
+                    'write': {}
+                }
+            }
+        }
+    }
+}
+
+
 class MsValidator(Validator):
-    """Add additional application checks"""
+    """Additional application checks."""
+
     ms_tagnames = {}
+    ms_notagcheck = {}
 
     def _validate_ms_tagname(self, constraint, field, value):
-        """ Test tagname exists, capture when true.
+        """
+        Test tagname exists, capture when true.
 
         The rule's arguments are validated against this schema:
-        {'type': 'boolean'}
+        {'type': 'string'}
         """
         if '.' in field:
             self._error(field, "'.' invalid in tag definition.")
-        if constraint:
+        if constraint == 'save':
             if field in self.ms_tagnames:
                 self._error(field, 'attempt to redefine')
             else:
                 self.ms_tagnames[field] = {'type': None}
-        else:
+        elif constraint == 'exists':
             if value not in self.ms_tagnames:
                 self._error(field, 'tag was not defined in tags.yaml')
-            else:
-                pass
+        elif constraint == 'none':
+            pass
+        else:
+            pass
 
     def _validate_ms_tagtype(self, constraint, field, value):
-        """ Test tagname type, capture when true.
+        """
+        Test tagname type, capture when true.
 
         The rule's arguments are validated against this schema:
         {'type': 'boolean'}
@@ -318,18 +402,22 @@ class MsValidator(Validator):
             pass
 
     def _validate_ms_ip(self, constraint, field, value):
-        """ Test session.inet_aton works for the address.
+        """
+        Test session.inet_aton works for the address.
 
         The rule's arguments are validated against this schema:
-        {'type': 'boolean'}
+        {'type': 'string'}
         """
-        try:
-            inet_aton(value)
-        except (OSError, TypeError):
-            self._error(field, 'ip address fails socket.inet_aton')
+        if value is None and 'none' in constraint:
+            pass
+        elif 'ipv4' in constraint:
+            try:
+                inet_aton(value)
+            except (OSError, TypeError):
+                self._error(field, 'ip address fails socket.inet_aton')
 
 
-def validate(path: str=None):
+def validate(path: str = None):
     """Validate."""
     s = {
         'tags': TAG_SCHEMA,
@@ -338,8 +426,10 @@ def validate(path: str=None):
         'history': HISTORY_SCHEMA,
         'modbusserver': MODBUSSERVER_SCHEMA,
         'modbusclient': MODBUSCLIENT_SCHEMA,
+        'snmpclient': SNMPCLIENT_SCHEMA,
+        'logixclient': LOGIXCLIENT_SCHEMA,
     }
-    prefix = ''
+    prefix = './'
     if path is not None:
         prefix = path + '/'
     c = {
@@ -349,8 +439,10 @@ def validate(path: str=None):
         'history': dict(Config(f'{prefix}history.yaml')),
         'modbusserver': dict(Config(f'{prefix}modbusserver.yaml')),
         'modbusclient': dict(Config(f'{prefix}modbusclient.yaml')),
+        'snmpclient': dict(Config(f'{prefix}snmpclient.yaml')),
+        'logixclient': dict(Config(f'{prefix}logixclient.yaml')),
     }
     v = MsValidator(s)
     res = v.validate(c)
     wdy = dump(v.errors)  # , default_flow_style=False)
-    return res, wdy
+    return res, wdy, prefix