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

pymscada/main.py

@@ -8,10 +8,13 @@ from pymscada.config import Config
 from pymscada.console import Console
 from pymscada.files import Files
 from pymscada.history import History
-from pymscada.modbus_client import ModbusClient
-from pymscada.modbus_server import ModbusServer
+from pymscada.iodrivers.logix_client import LogixClient
+from pymscada.iodrivers.modbus_client import ModbusClient
+from pymscada.iodrivers.modbus_server import ModbusServer
+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():
@@ -22,7 +25,11 @@ def args():
         epilog='Python MobileSCADA.'
     )
     commands = ['bus', 'console', 'wwwserver', 'history', 'files',
-                'modbusserver', 'modbusclient', 'simulate', 'checkout']
+                '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',
@@ -32,7 +39,7 @@ def args():
     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.")
+                        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()
@@ -63,12 +70,18 @@ async def run():
     elif options.module == 'files':
         config = Config(options.config)
         module = Files(**config)
+    elif options.module == 'logixclient':
+        config = Config(options.config)
+        module = LogixClient(**config)
     elif options.module == 'modbusclient':
         config = Config(options.config)
         module = ModbusClient(**config)
     elif options.module == 'modbusserver':
         config = Config(options.config)
         module = ModbusServer(**config)
+    elif options.module == 'snmpclient':
+        config = Config(options.config)
+        module = SnmpClient(**config)
     elif options.module == 'simulate':
         config = Config(options.config)
         tag_info = dict(Config(options.tags))
@@ -76,6 +89,13 @@ async def run():
     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()

pymscada/periodic.py

@@ -36,6 +36,6 @@ class Periodic:
             if sleep_for < 0.0:
                 sleep_for = self.period
                 self._time = time.time()
-                logging.warn(f'{self._func} skipped at {self._time}')
+                logging.warning(f'{self._func} skipped at {self._time}')
             else:
                 await asyncio.sleep(sleep_for)

pymscada/samplers.py

@@ -0,0 +1,93 @@
+"""Sampling utilities."""
+from pathlib import Path
+import shutil
+from pymscada.tag import Tag
+
+
+CPU_TEMP = False
+if Path('/sys/class/thermal/thermal_zone0/temp').is_file():
+    CPU_TEMP = True
+with open('/proc/stat', 'r') as f:
+    cpu_load = [int(x) for x in f.readline().split(None)[1:]]
+
+
+def get_cpu_temp() -> float:
+    """Return the CPU temp in °C."""
+    temp = 0.
+    if not CPU_TEMP:
+        return temp
+    with open('/sys/class/thermal/thermal_zone0/temp', 'r') as f:
+        temp = int(f.read()) / 1000
+    return temp
+
+
+def get_cpu_load() -> float:
+    """Return cpu load in %."""
+    global cpu_load
+    old_cpu_load = cpu_load
+    with open('/proc/stat', 'r') as f:
+        cpu_load = [int(x) for x in f.readline().split(None)[1:]]
+    idle = cpu_load[3] - old_cpu_load[3]
+    used = sum(cpu_load) - sum(old_cpu_load)
+    if used == 0:
+        return 0
+    return 100 * (used - idle) / used
+
+
+def get_disk_use() -> float:
+    """Return disk usage in %."""
+    stat = shutil.disk_usage(Path('/'))
+    return 100 * stat.used / stat.total
+
+
+class Ping():
+    """Async ping class."""
+
+    def __init__(self, map: dict[str: Tag]) -> None:
+        """Ping map, key as IP address, time placed into Tag.value."""
+        self.map = map
+
+    def step(self):
+        """Step."""
+        pass
+
+
+class Ramp():
+    """Ramp a value."""
+
+    def __init__(self, ramp_tag: Tag, setpoint_tag: Tag, ramp=1) -> None:
+        """Ramp."""
+        self.ramp_tag = ramp_tag
+        self.setpoint_tag = setpoint_tag
+        self.ramp = ramp
+
+    def step(self) -> None:
+        """Step."""
+        if self.setpoint_tag.value is None:
+            return
+        if self.ramp_tag.value is None:
+            self.ramp_tag.value = self.setpoint_tag.value
+            return
+        if self.setpoint_tag.value > self.ramp_tag.value:
+            self.ramp_tag.value = min(self.ramp_tag.value + self.ramp,
+                                      self.setpoint_tag.value)
+        else:
+            self.ramp_tag.value = max(self.ramp_tag.value - self.ramp,
+                                      self.setpoint_tag.value)
+
+
+class Average():
+    """Average a value."""
+
+    def __init__(self, tag: Tag, count=60) -> None:
+        """Average."""
+        self.tag = tag
+        self.count = count
+        self.samples = []
+
+    def step(self, sample: float) -> None:
+        """Take a sample, update tag value if count samples taken."""
+        self.samples.append(sample)
+        if len(self.samples) == self.count:
+            self.tag.value = sum(self.samples) / self.count
+            self.samples = []

pymscada/tag.py

@@ -18,33 +18,6 @@ TYPES = {
 }
 
 
-def validate_tag(tag: dict):
-    """Correct tag dictionary in place."""
-    if 'desc' not in tag:
-        logging.error(f"{tag} missing desc")
-    if 'multi' in tag:
-        if 'type' in tag:
-            logging.warning(f"{tag} redundant type cast for multi")
-        tag['type'] = int
-    else:
-        if 'type' not in tag:
-            tag['type'] = float
-        else:
-            try:
-                tag['type'] = TYPES[tag['type']]
-            except KeyError:
-                logging.error(f"{tag} invalid type {tag['type']}")
-    if tag['type'] is int:
-        if 'dp' in tag:
-            logging.warning(f"{tag} redundant dp for int")
-        tag['dp'] = 0
-    elif tag['type'] is float and 'dp' not in tag:
-        tag['dp'] = 2
-    elif tag['type'] in [str, bytes] and 'dp' in tag:
-        logging.warning(f"{tag} str/bytes cannot use dp")
-        del tag['dp']
-
-
 class UniqueTag(type):
     """Super Tag class only create unique tags for unique tag names."""
 

pymscada/tools/walk.py

@@ -0,0 +1,55 @@
+"""
+Walk whole MIB
+++++++++++++++
+
+Send a series of SNMP GETNEXT requests using the following options:
+
+* with SNMPv3, user 'usr-md5-none', MD5 authentication, no privacy
+* over IPv4/UDP
+* to an Agent at demo.snmplabs.com:161
+* for all OIDs in IF-MIB
+
+Functionally similar to:
+
+| $ snmpwalk -v3 -lauthPriv -u usr-md5-none -A authkey1 -X privkey1 demo.snmplabs.com  IF-MIB::
+
+"""#
+from pysnmp.hlapi import *
+
+mibs = {
+    'MIKROTIK-MIB': '1.3.6.1.4.1.14988',
+    'MIB-2': '1.3.6.1.2.1',
+    'HOST-RESOURCES-MIB': '1.3.6.1.2.1.25',
+    'IF-MIB': '1.3.6.1.2.1.2',
+    'IP-MIB': '1.3.6.1.2.1.4',
+    'IP-FORWARD-MIB': '1.3.6.1.2.1.4.21',
+    'IPV6-MIB': '1.3.6.1.2.1.55',
+    'BRIDGE-MIB': '1.3.6.1.2.1.17',
+    'DHCP-SERVER-MIB': '1.3.6.1.4.1.14988.1.1.8',
+    'CISCO-AAA-SESSION-MIB': '1.3.6.1.4.1.9.9.39',
+    'ENTITY-MIB': '1.3.6.1.2.1.47',
+    'UPS-MIB': '1.3.6.1.2.1.33',
+    'SQUID-MIB': '1.3.6.1.4.1.3495',
+}
+
+iterator = nextCmd(
+    SnmpEngine(),
+    UsmUserData('public'),
+    UdpTransportTarget(('172.26.3.254', 161)),
+    ContextData(),
+    # ObjectType(ObjectIdentity('1.3.6.1.2.1.1.1.0')),
+    # ObjectType(ObjectIdentity('1.3.6.1.2.1.1.6.0'))
+    ObjectType(ObjectIdentity(mibs['MIB-2']))
+)
+
+for errorIndication, errorStatus, errorIndex, varBinds in iterator:
+    if errorIndication:
+        print(errorIndication)
+        break
+    elif errorStatus:
+        print('%s at %s' % (errorStatus.prettyPrint(),
+                            errorIndex and varBinds[int(errorIndex) - 1][0] or '?'))
+        break
+    else:
+        for varBind in varBinds:
+            print(' = '.join([x.prettyPrint() for x in varBind]))

pymscada/validate.py

@@ -0,0 +1,356 @@
+"""Config file validation."""
+from cerberus import Validator
+from yaml import dump
+from pymscada import Config
+from socket import inet_aton
+
+INT_TAG = {
+    'desc': {'type': 'string'},
+    'type': {'type': 'string', 'allowed': ['int']},
+    'min': {'type': 'integer', 'required': False},
+    'max': {'type': 'integer', 'required': False},
+    'init': {'type': 'integer', 'required': False},
+    'units': {'type': 'string', 'maxlength': 5, 'required': False},
+    'format': {'type': 'string', 'allowed': ['date', 'time', 'datetime']}
+}
+FLOAT_TAG = {
+    'desc': {'type': 'string'},
+    'type': {'type': 'string', 'allowed': ['float']},
+    'min': {'type': 'float', 'required': False},
+    'max': {'type': 'float', 'required': False},
+    'init': {'type': 'float', 'required': False},
+    'units': {'type': 'string', 'maxlength': 5, 'required': False},
+    'dp': {'type': 'integer', 'min': 0, 'max': 6, 'required': False},
+}
+STR_TAG = {
+    'desc': {'type': 'string'},
+    'type': {'type': 'string', 'allowed': ['str']},
+    'init': {'type': 'string', 'required': False},
+}
+LIST_TAG = {
+    'desc': {'type': 'string'},
+    'type': {'type': 'string', 'allowed': ['list']},
+}
+DICT_TAG = {
+    'desc': {'type': 'string'},
+    'type': {'type': 'string', 'allowed': ['dict']},
+    'init': {}
+}
+MULTI_TAG = {
+    'desc': {'type': 'string'},
+    'multi': {'type': 'list'},
+    'init': {'type': 'integer', 'required': False},
+}
+BYTES_TAG = {
+    'desc': {'type': 'string'},
+    'type': {'type': 'string', 'allowed': ['bytes']},
+}
+
+TAG_SCHEMA = {
+    'type': 'dict',
+    'keysrules': {
+        'type': 'string',
+        # tag name discovery, save for later checking
+        'ms_tagname': True
+    },
+    'valuesrules': {
+        'type': 'dict',
+        'oneof_schema': [
+            INT_TAG, FLOAT_TAG, STR_TAG, LIST_TAG, DICT_TAG, MULTI_TAG,
+            BYTES_TAG
+        ],
+        # tag type discovery, save for later checking
+        'ms_tagtype': True
+    },
+}
+
+BUS_SCHEMA = {
+    'type': 'dict',
+    'schema': {
+        'ip': {'type': 'string', 'ms_ip': True},
+        'port': {'type': 'integer', 'min': 1024, 'max': 65536}
+    }
+}
+
+BRHR_LIST = {
+    'type': {'type': 'string', 'allowed': ['br', 'hr']},
+}
+H123P_LIST = {
+    'type': {
+        'type': 'string',
+        'allowed': ['h1', 'h2', 'h3', 'p'],
+    },
+    'desc': {'type': 'string'}
+}
+VALUESETFILES_LIST = {
+    'type': {
+        'type': 'string',
+        'allowed': ['value', 'setpoint', 'files'],
+    },
+    # tagname must have been found in parsing tags.yaml
+    'tagname': {'type': 'string', 'ms_tagname': False}
+}
+SELECTDICT_LIST = {
+    'type': {'type': 'string', 'allowed': ['selectdict']},
+    # tagname must have been found in parsing tags.yaml
+    'tagname': {'type': 'string', 'ms_tagname': False},
+    'opts': {
+        'type': 'dict',
+        # 'schema': {
+        #     'type': 'dict',
+        #     # 'schema': {
+        #     #     'type': {'type': 'string', 'required': False},
+        #     #     'multi': {'type': 'list', 'required': False},
+        #     # }
+        # },
+        'required': False
+    }
+}
+UPLOT_LIST = {
+    'type': {'type': 'string', 'allowed': ['uplot']},
+    'ms': {
+        'type': 'dict',
+        # 'schema': {
+        #     'type': 'dict',
+        #     # 'schema': {
+        #     #     'type': {'type': 'string', 'required': False},
+        #     #     'multi': {'type': 'list', 'required': False},
+        #     # }
+        # },
+        'required': False
+    },
+    'axes': {
+        'type': 'list',
+        'schema': {
+            'type': 'dict',
+            'schema': {
+                'scale': {'type': 'string'},
+                'range': {'type': 'list', 'items': [
+                    {'type': 'float'}, {'type': 'float'}
+                ]},
+                'dp': {'type': 'integer', 'required': False}
+            }
+        }
+    },
+    'series': {
+        'type': 'list',
+        'schema': {
+            'type': 'dict',
+            'schema': {
+                # tagname must have been found in parsing tags.yaml
+                'tagname': {'type': 'string', 'ms_tagname': False},
+                'label': {'type': 'string', 'required': False},
+                'scale': {'type': 'string', 'required': False},
+                'color': {'type': 'string', 'required': False},
+                'width': {'type': 'float', 'required': False},
+                'dp': {'type': 'integer', 'required': False},
+            }
+        }
+    }
+}
+
+LIST_WWWSERVER = {
+    'type': 'dict',
+    'schema': {
+        'name': {'type': 'string'},
+        'parent': {'type': 'string', 'nullable': True},
+        'items': {
+            'type': 'list',
+            'schema': {
+                'type': 'dict',
+                'oneof_schema': [
+                    BRHR_LIST, H123P_LIST, VALUESETFILES_LIST,
+                    SELECTDICT_LIST, UPLOT_LIST
+                ]
+            }
+        },
+    }
+}
+
+WWWSERVER_SCHEMA = {
+    'type': 'dict',
+    'schema': {
+        'bus_ip': {'type': 'string', 'ms_ip': True},
+        'bus_port': {'type': 'integer', 'min': 1024, 'max': 65536},
+        'ip': {'type': 'string', 'ms_ip': True},
+        'port': {'type': 'integer', 'min': 1024, 'max': 65536},
+        'get_path': {'nullable': True},
+        'paths': {'type': 'list', 'allowed': ['history', 'config', 'pdf']},
+        'pages': {
+            'type': 'list',
+            'schema': LIST_WWWSERVER
+        }
+    }
+}
+
+HISTORY_SCHEMA = {
+    'type': 'dict',
+    'schema': {
+        'bus_ip': {'type': 'string', 'ms_ip': True},
+        'bus_port': {'type': 'integer', 'min': 1024, 'max': 65536},
+        'path': {'type': 'string'},
+    }
+}
+
+MODBUSSERVER_SCHEMA = {
+    'type': 'dict',
+    'schema': {
+        'bus_ip': {'type': 'string', 'ms_ip': True, 'nullable': True},
+        'bus_port': {'type': 'integer', 'min': 1024, 'max': 65536,
+                     'nullable': True},
+        'path': {'type': 'string'},
+        'rtus': {
+            'type': 'list',
+            'schema': {
+                'type': 'dict',
+                'schema': {
+                    'name': {},
+                    'ip': {},
+                    'port': {},
+                    'tcp_udp': {'type': 'string', 'allowed': ['tcp', 'udp']},
+                    'serve': {
+                        'type': 'list',
+                        'schema': {}
+                    }
+                }
+            }
+        },
+        'tags': {
+            'type': 'dict',
+            'keysrules': {
+                'type': 'string',
+                'ms_tagname': False
+            },
+            'valuesrules': {
+                'type': 'dict',
+                'schema': {
+                    'type': {},
+                    'addr': {}
+                },
+            },
+        },
+    }
+}
+
+MODBUSCLIENT_SCHEMA = {
+    'type': 'dict',
+    'schema': {
+        'bus_ip': {'type': 'string', 'ms_ip': True, 'nullable': True},
+        'bus_port': {'type': 'integer', 'min': 1024, 'max': 65536,
+                     'nullable': True},
+        'path': {'type': 'string'},
+        'rtus': {
+            'type': 'list',
+            'schema': {
+                'type': 'dict',
+                'schema': {
+                    'name': {},
+                    'ip': {},
+                    'port': {},
+                    'tcp_udp': {'type': 'string', 'allowed': ['tcp', 'udp']},
+                    'rate': {},
+                    'read': {
+                        'type': 'list',
+                        'schema': {}
+                    },
+                    'writeok': {
+                        'type': 'list',
+                        'schema': {}
+                    }
+                }
+            }
+        },
+        'tags': {
+            'type': 'dict',
+            'keysrules': {
+                'type': 'string',
+                'ms_tagname': False
+            },
+            'valuesrules': {
+                'type': 'dict',
+                'schema': {
+                    'type': {},
+                    'addr': {}
+                },
+            }
+        }           
+    }
+}
+
+class MsValidator(Validator):
+    """Add additional application checks"""
+    ms_tagnames = {}
+
+    def _validate_ms_tagname(self, constraint, field, value):
+        """ Test tagname exists, capture when true.
+
+        The rule's arguments are validated against this schema:
+        {'type': 'boolean'}
+        """
+        if '.' in field:
+            self._error(field, "'.' invalid in tag definition.")
+        if constraint:
+            if field in self.ms_tagnames:
+                self._error(field, 'attempt to redefine')
+            else:
+                self.ms_tagnames[field] = {'type': None}
+        else:
+            if value not in self.ms_tagnames:
+                self._error(field, 'tag was not defined in tags.yaml')
+            else:
+                pass
+
+    def _validate_ms_tagtype(self, constraint, field, value):
+        """ Test tagname type, capture when true.
+
+        The rule's arguments are validated against this schema:
+        {'type': 'boolean'}
+        """
+        if constraint and field in self.ms_tagnames:
+            if self.ms_tagnames[field]['type'] is None:
+                if 'multi' in value:
+                    self.ms_tagnames[field]['type'] = 'int'
+                else:
+                    self.ms_tagnames[field]['type'] = value['type']
+            else:
+                self._error(field, 'attempt to redefine type')
+        else:
+            pass
+
+    def _validate_ms_ip(self, constraint, field, value):
+        """ Test session.inet_aton works for the address.
+
+        The rule's arguments are validated against this schema:
+        {'type': 'boolean'}
+        """
+        try:
+            inet_aton(value)
+        except (OSError, TypeError):
+            self._error(field, 'ip address fails socket.inet_aton')
+
+
+def validate(path: str=None):
+    """Validate."""
+    s = {
+        'tags': TAG_SCHEMA,
+        'bus': BUS_SCHEMA,
+        'wwwserver': WWWSERVER_SCHEMA,
+        'history': HISTORY_SCHEMA,
+        'modbusserver': MODBUSSERVER_SCHEMA,
+        'modbusclient': MODBUSCLIENT_SCHEMA,
+    }
+    prefix = ''
+    if path is not None:
+        prefix = path + '/'
+    c = {
+        'tags': dict(Config(f'{prefix}tags.yaml')),
+        'bus': dict(Config(f'{prefix}bus.yaml')),
+        'wwwserver': dict(Config(f'{prefix}wwwserver.yaml')),
+        'history': dict(Config(f'{prefix}history.yaml')),
+        'modbusserver': dict(Config(f'{prefix}modbusserver.yaml')),
+        'modbusclient': dict(Config(f'{prefix}modbusclient.yaml')),
+    }
+    v = MsValidator(s)
+    res = v.validate(c)
+    wdy = dump(v.errors)  # , default_flow_style=False)
+    return res, wdy