pymscada 0.2.6b2__tar.gz → 0.2.6b10__tar.gz

{pymscada-0.2.6b2/src/pymscada.egg-info → pymscada-0.2.6b10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymscada
-Version: 0.2.6b2
+Version: 0.2.6b10
 Summary: Shared tag value SCADA with python backup and Angular UI
 Author-email: Jamie Walton <jamie@walton.net.nz>
 License: GPL-3.0-or-later
@@ -17,7 +17,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: PyYAML>=6.0.1
 Requires-Dist: aiohttp>=3.8.5
-Requires-Dist: pymscada-html>=0.2.2
+Requires-Dist: pymscada-html>=0.2.6b0
 Requires-Dist: cerberus>=1.3.5
 Requires-Dist: pycomm3>=1.2.14
 Requires-Dist: pysnmplib>=5.0.24

{pymscada-0.2.6b2 → pymscada-0.2.6b10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pymscada"
-version = "0.2.6b2"
+version = "0.2.6b10"
 description = "Shared tag value SCADA with python backup and Angular UI"
 authors = [
     {name = "Jamie Walton", email = "jamie@walton.net.nz"},
@@ -8,7 +8,7 @@ authors = [
 dependencies = [
     "PyYAML>=6.0.1",          # all
     "aiohttp>=3.8.5",         # www_server
-    "pymscada-html>=0.2.2",   # www_server
+    "pymscada-html>=0.2.6b0",   # www_server
     "cerberus>=1.3.5",        # validate
     "pycomm3>=1.2.14",        # logix_client
     "pysnmplib>=5.0.24",      # DON'T use pysnmp, dead

{pymscada-0.2.6b2 → pymscada-0.2.6b10}/src/pymscada/__init__.py

@@ -2,7 +2,7 @@
 from pymscada.bus_client import BusClient
 from pymscada.bus_server import BusServer
 from pymscada.config import Config
-from pymscada.callout import Callout, alarm_in_group, ALM
+from pymscada.callout import Callout, ALM
 from pymscada.iodrivers.accuweather import AccuWeatherClient
 from pymscada.iodrivers.logix_client import LogixClient
 from pymscada.iodrivers.modbus_client import ModbusClient
@@ -18,7 +18,7 @@ __all__ = [
     'BusClient',
     'BusServer',
     'Config',
-    'Callout', 'alarm_in_group', ALM,
+    'Callout', 'ALM',
     'AccuWeatherClient',
     'LogixClient',
     'ModbusClient',

{pymscada-0.2.6b2 → pymscada-0.2.6b10}/src/pymscada/alarms.py

@@ -117,6 +117,8 @@ class Alarm():
         self.tag.add_callback(self.callback)
         self.group = group
         self.state_cb = state_cb
+        self.timing_value = None
+        self.timing_us = None
         self.alarm = split_operator(alarm)
         self.in_alarm = False
         self.disabled_until = 0
@@ -143,9 +145,15 @@ class Alarm():
         if new_in_alarm:
             if self.alarm['for'] > 0:
                 self.state_cb(self, TIMING)
+                self.timing_us = tag.time_us
+                self.timing_value = value
             else:
                 self.state_cb(self, ALM)
         else:
+            if self.timing_us is not None:
+                if tag.time_us - self.timing_us >= self.alarm['for'] * 1000000:
+                    self.state_cb(self, ALM)
+            self.timing_us = None
             self.state_cb(self, RTN)
         self.in_alarm = new_in_alarm
 
@@ -220,17 +228,14 @@ class Alarms:
         self.connection = sqlite3.connect(db)
         self.table = table
         self.cursor = self.connection.cursor()
-        
-        # Check SQLite version for RETURNING clause support (requires >= 3.35.0)
         sqlite_version = sqlite3.sqlite_version_info
         self.has_returning = sqlite_version >= (3, 35, 0)
         if not self.has_returning:
             logging.warning(
-                f'SQLite version {sqlite3.sqlite_version} is older than 3.35.0. '
+                f'SQLite {sqlite3.sqlite_version} is older than 3.35.0. '
                 f'RETURNING clause not supported, using fallback method. '
                 f'Consider upgrading SQLite for better performance.'
             )
-        
         query = (
             'CREATE TABLE IF NOT EXISTS ' + self.table + ' '
             '(id INTEGER PRIMARY KEY ASC, '
@@ -242,7 +247,6 @@ class Alarms:
         )
         self.cursor.execute(query)
         self.connection.commit()
-        
         startup_record = {
             'action': 'ADD',
             'date_ms': int(time.time() * 1000),
@@ -278,6 +282,8 @@ class Alarms:
     def generate_alarm(self, alarm: Alarm, kind: int):
         """Generate alarm message."""
         value = alarm.tag.value
+        if alarm.timing_us is not None:
+            value = alarm.timing_value
         time_us = alarm.tag.time_us
         logging.warning(f'Alarm {alarm.alarm_id} {value} {KIND[kind]}')
         self.rta_cb({

{pymscada-0.2.6b2 → pymscada-0.2.6b10}/src/pymscada/bus_client.py

@@ -77,10 +77,6 @@ class BusClient:
         jsonstr = json.dumps(request).encode()
         size = len(jsonstr)
         data = struct.pack(f'>B{size}s', pc.TYPE.JSON, jsonstr)
-        action = request.get("action", "unknown")
-        tag_id = self.tag_by_name[tagname].id
-        logging.info(f'{self.module}: RTA sending {tagname} {action} to'
-                     f' tag_id {tag_id}')
         self.write(pc.COMMAND.RTA, self.tag_by_name[tagname].id, time_us, data)
 
     def write(self, command: pc.COMMAND, tag_id: int, time_us: int,
@@ -221,9 +217,8 @@ class BusClient:
             data = struct.unpack_from(f'!{len(value) - 1}s', value, offset=1
                                       )[0].decode()
             data = json.loads(data)
-            action = data.get("action", "unknown")
-            logging.info(f'{self.module}: RTA received {tag.name} {action} '
-                        f'from tag_id {tag_id}')
+            logging.info(f'{self.module}: RTA received {tag.name} {data} '
+                         f'from tag_id {tag_id}')
             try:
                 self.rta_handlers[tag.name](data)
             except KeyError:

{pymscada-0.2.6b2 → pymscada-0.2.6b10}/src/pymscada/bus_server.py

@@ -18,8 +18,7 @@ class BusTags(type):
         """Return existing tag if tagname already exists."""
         if tagname in cls._tag_by_name:
             return cls._tag_by_name[tagname]
-        tag: 'BusTag' = cls.__new__(cls, tagname)
-        tag.__init__(tagname)
+        tag: 'BusTag' = super().__call__(tagname)
         tag.id = cls._next_id
         cls._next_id += 1
         cls._tag_by_name[tagname] = tag
@@ -35,10 +34,10 @@ class BusTag(metaclass=BusTags):
     def __init__(self, name: bytes):
         """Name and id must be unique."""
         self.name = name
-        self.id = None
+        self.id = 0
         self.time_us: int = 0
         self.value: bytes = b''
-        self.from_bus: 'BusConnection' = None
+        self.from_bus: int = 0
         self.pub = []
 
     def add_callback(self, callback, bus_id):
@@ -51,7 +50,7 @@ class BusTag(metaclass=BusTags):
         if (callback, bus_id) in self.pub:
             self.pub.remove((callback, bus_id))
 
-    def update(self, data: bytes, time_us: int, from_bus: 'BusConnection'):
+    def update(self, data: bytes, time_us: int, from_bus: int):
         """Assign value and update subscribers."""
         self.value = data
         self.time_us = time_us
@@ -111,7 +110,8 @@ class BusConnection():
                 head = await self.reader.readexactly(14)
                 _, cmd, tag_id, size, time_us = unpack('!BBHHQ', head)
             except (ConnectionResetError, asyncio.IncompleteReadError,
-                    asyncio.CancelledError):
+                    asyncio.CancelledError) as e:
+                logging.warning(f'{self.addr} read error: {e}')
                 break
             # if the command packet indicates data, get that too
             if size == 0:
@@ -121,7 +121,8 @@ class BusConnection():
                 payload = await self.reader.readexactly(size)
                 data = unpack(f'!{size}s', payload)[0]
             except (ConnectionResetError, asyncio.IncompleteReadError,
-                    asyncio.CancelledError):
+                    asyncio.CancelledError) as e:
+                logging.warning(f'{self.addr} read payload error: {e}')
                 break
             # if MAX_LEN then a continuation packet is required
             if size == pc.MAX_LEN:
@@ -289,7 +290,7 @@ class BusServer:
                 self.bus_tag.value = f'\x03{client_addr}: {log_msg}'.encode()
                 self.bus_tag.time_us = int(time.time() * 1e6)
         else:  # consider disconnecting
-            logging.warn(f'invalid message {cmd}')
+            logging.warning(f'invalid message {cmd}')
 
     def read_callback(self, command):
         """Process read messages, delete broken connections."""

pymscada-0.2.6b10/src/pymscada/callout.py

@@ -0,0 +1,304 @@
+"""Callout handling."""
+import logging
+import socket
+import time
+from pymscada.bus_client import BusClient
+from pymscada.periodic import Periodic
+from pymscada.tag import Tag
+
+
+"""
+Callout monitors alarms and sends SMS notifications to configured callees.
+
+Configuration:
+- callees: list of recipients with SMS numbers, delays, and group filters
+- alarms_tag: RTA tag receiving alarms from alarms.py
+- ack_tag: tag for receiving acknowledgments
+- rta_tag: tag for configuration updates and SMS requests
+
+Operation:
+1. Collect alarms from alarms_tag (kind=ALM)
+2. For each callee, check if alarms match their group filter and delay
+3. Send SMS via rta_tag when conditions are met
+4. Track sent notifications in alarm['sent'] hash
+5. Remove alarms when callee acknowledges (matches their group)
+"""
+
+ALM = 0
+RTN = 1
+
+IDLE = 0
+NEW_ALM = 1
+CALLOUT = 2
+
+SENT = 0
+REMIND = 1
+
+
+class CalloutCallee:
+    """Track status of callee for callout."""
+
+    def __init__(self, callee: dict):
+        if not isinstance(callee, dict) or 'name' not in callee or \
+                'sms' not in callee:
+            logging.warning(f'Callee malformed {callee}')
+            return
+        self.name = callee['name']
+        self.sms = callee['sms']
+        self.role = callee.get('role', '')
+        self.group = callee.get('group', '')
+        self.delay_ms = 0
+
+    def set_role(self, role: str, delay_ms: int):
+        self.role = role
+        self.delay_ms = delay_ms
+
+    def set_group(self, group: str):
+        self.group = group
+
+
+class CalloutAlarm:
+    """Track status of alarm for callout."""
+
+    def __init__(self, alm_tag_value):
+        if not isinstance(alm_tag_value, dict) or \
+                'date_ms' not in alm_tag_value or \
+                'alarm_string' not in alm_tag_value or \
+                'desc' not in alm_tag_value or \
+                'group' not in alm_tag_value or \
+                'kind' not in alm_tag_value:
+            logging.warning(f'alarms_cb malformed {alm_tag_value}')
+            raise ValueError(f'alarms_cb malformed {alm_tag_value}')
+        self.date_ms = alm_tag_value['date_ms']
+        self.alarm_string = alm_tag_value['alarm_string']
+        self.desc = alm_tag_value['desc']
+        self.group = alm_tag_value['group']
+        self.sent: set[CalloutCallee] = set()
+        self.remind: set[CalloutCallee] = set()
+
+    def callee_in_group(self, callee: CalloutCallee, groups: dict):
+        if callee.group == '':
+            return True
+        if callee.group not in groups:
+            return False
+        group = groups[callee.group]
+        if 'tagnames' in group:
+            for tagname in group['tagnames']:
+                if self.alarm_string.startswith(tagname):
+                    return True
+        if 'groups' in group:
+            for group in group['groups']:
+                if self.group in group:
+                    return True
+        return False
+
+
+class Callout:
+    """Connect to bus_ip:bus_port, monitor alarms and manage callouts."""
+
+    def __init__(
+        self,
+        bus_ip: str | None = '127.0.0.1',
+        bus_port: int | None = 1324,
+        rta_tag: str = '__callout__',
+        alarms_tag: str | None = None,
+        sms_send_tag: str | None = None,
+        sms_recv_tag: str | None = None,
+        ack_tag: str | None = None,
+        status_tag: str | None = None,
+        callees: list = [],
+        groups: dict = {},
+        escalation: dict = {}
+    ) -> None:
+        """
+        Connect to bus_ip:bus_port, monitor alarms and manage callouts.
+
+        Monitor alarms via alarms_tag and manage callout messages to callees
+        based on configured delays and area filters.
+
+        Event loop must be running.
+
+        For testing only: bus_ip can be None to skip connection.
+        """
+        if bus_ip is None:
+            logging.warning('Callout has bus_ip=None, only use for testing')
+        else:
+            try:
+                socket.gethostbyname(bus_ip)
+            except socket.gaierror as e:
+                raise ValueError(f'Cannot resolve IP/hostname: {e}')
+            if not isinstance(bus_port, int):
+                raise TypeError('bus_port must be an integer')
+            if not 1024 <= bus_port <= 65535:
+                raise ValueError('bus_port must be between 1024 and 65535')
+        if not isinstance(rta_tag, str) or not rta_tag:
+            raise ValueError('rta_tag must be a non-empty string')
+        if alarms_tag is None:
+            raise ValueError('alarms_tag must be defined')
+        if sms_send_tag is None:
+            raise ValueError('sms_send_tag must be defined')
+        if sms_recv_tag is None:
+            raise ValueError('sms_recv_tag must be defined')
+
+        logging.warning(f'Callout {bus_ip} {bus_port} {rta_tag} '
+                        f'{sms_send_tag} {sms_recv_tag}')
+        self.callees: list[CalloutCallee] = []
+        for callee in callees:
+            self.callees.append(CalloutCallee(callee))
+        self.groups = groups
+        self.escalation = escalation
+        self.alarms: list[CalloutAlarm] = []
+        self.alarms_tag = Tag(alarms_tag, dict)
+        self.alarms_tag.add_callback(self.alarms_cb)
+        self.sms_recv_tag = Tag(sms_recv_tag, dict)
+        self.sms_recv_tag.add_callback(self.sms_recv_cb)
+        self.sms_send_tag = Tag(sms_send_tag, dict)
+        if ack_tag is not None:
+            self.ack_tag = Tag(ack_tag, int)
+            self.ack_tag.add_callback(self.ack_cb)
+        if status_tag is not None:
+            self.status = Tag(status_tag, int)
+        else:
+            self.status = None
+        self.busclient = BusClient(bus_ip, bus_port, module='Callout')
+        self.rta = Tag(rta_tag, dict)
+        self.set_rta_value(rta_id=0)
+        self.busclient.add_callback_rta(rta_tag, self.rta_cb)
+        self.periodic = Periodic(self.periodic_cb, 1.0)
+
+    def set_rta_value(self, rta_id: int):
+        """Publish the current configuration to the RTA tag."""
+        callees = [{'name': callee.name, 'sms': callee.sms, 'role': callee.role,
+                    'group': callee.group, 'delay_ms': callee.delay_ms}
+                    for callee in self.callees]
+        self.rta.value = {'__rta_id__': rta_id,
+                          'callees': callees,
+                          'groups': self.groups,
+                          'escalation': list(self.escalation.keys())}
+
+    def alarms_cb(self, alm_tag):
+        """Handle alarm messages from alarms.py."""
+        if alm_tag.value['kind'] != ALM:
+            return
+        alarm = CalloutAlarm(alm_tag.value)
+        self.alarms.append(alarm)
+        logging.info(f'Added alarm to list: {alarm}')
+        if self.status is not None and self.status.value == IDLE:
+            self.status.value = NEW_ALM
+
+    def ack_cb(self, ack_tag):
+        """Handle ACK requests for alarm acknowledgment."""
+        if ack_tag.value == 1:
+            self.alarms = []
+            if self.status is not None:
+                self.status.value = IDLE
+            logging.info('ACK: all alarms cleared')
+
+    def sms_recv_cb(self, sms_recv_tag: Tag):
+        """Handle SMS messages from the modem."""
+        logging.info(f'sms_recv_cb {sms_recv_tag.value}')
+        if not isinstance(sms_recv_tag.value, dict) or \
+                'number' not in sms_recv_tag.value or \
+                'message' not in sms_recv_tag.value:
+            logging.warning(f'sms_recv_cb invalid {sms_recv_tag.value}')
+            return
+        number = sms_recv_tag.value['number']
+        name = [callee.name for callee in self.callees if callee.sms == number][0]
+        message = sms_recv_tag.value['message'][:2].upper()
+        if message in ['OK', 'AC', 'TH', 'YE']:
+            new_alarms = []
+            for alarm in self.alarms:
+                if name in alarm.sent:
+                    continue
+                new_alarms.append(alarm)
+            self.alarms = new_alarms
+            if self.status is not None:
+                self.status.value = IDLE
+            logging.info(f'ACK: remaining alarms {len(new_alarms)}')
+
+    def rta_cb(self, request):
+        """Handle RTA requests for callout configuration."""
+        logging.info(f'rta_cb {request}')
+        if 'action' not in request:
+            logging.warning(f'rta_cb malformed {request}')
+            return
+        if request['action'] == 'GET CONFIG':
+            self.set_rta_value(rta_id=request['__rta_id__'])
+        elif request['action'] == 'MODIFY':
+            for callee in self.callees:
+                if callee.name == request['name']:
+                    if not 'role' in request and not 'group' in request:
+                        logging.warning(f'rta_cb invalid request: {request}')
+                        return
+                    role = request['role']
+                    group = request['group']
+                    valid_role = role == '' or role in self.escalation
+                    valid_group = group == '' or group in self.groups
+                    if not valid_role or not valid_group:
+                        logging.warning(f'rta_cb MODIFY invalid: {request}')
+                        return
+                    callee.set_role(role, self.escalation.get(role, 0))
+                    callee.set_group(group)
+            self.set_rta_value(rta_id=0)
+
+    def check_callee_messages(self, callee: CalloutCallee, time_ms):
+        if callee.role == '':
+            return ''
+        callee_alarms = set()
+        for alarm in self.alarms:
+            if alarm.callee_in_group(callee, self.groups):
+                callee_alarms.add(alarm)
+        notify_message = ''
+        remind_message = ''
+        notify_ms = time_ms - callee.delay_ms
+        remind_ms = notify_ms - 60000
+        notify = []
+        remind = []
+        for alarm in callee_alarms:
+            if not callee.name in alarm.sent and notify_ms > alarm.date_ms:
+                notify_message += f'{alarm.desc}\n'
+                alarm.sent.add(callee.name)
+            else:
+                notify.append(alarm)
+            if not callee.name in alarm.remind and remind_ms > alarm.date_ms:
+                remind_message += f'{alarm.desc}\n'
+                alarm.remind.add(callee.name)
+            else:
+                remind.append(alarm)
+        message = ''
+        if notify_message != '':
+            message += f'ALARMS\n{notify_message}'
+            for alarm in notify:
+                message += f'{alarm.desc}\n'
+                alarm.sent.add(callee.name)
+        if remind_message != '':
+            message += f'REMINDERS\n{remind_message}'
+            for alarm in remind:
+                message += f'{alarm.desc}\n'
+                alarm.remind.add(callee.name)
+        message = message.rstrip('\n')
+        return message
+
+    def check_alarms(self):
+        """Check alarms for each callee."""
+        time_ms = int(time.time() * 1000)
+        for callee in self.callees:
+            message = self.check_callee_messages(callee, time_ms)
+            if message == '':
+                continue
+            logging.info(f'Sending message to {callee.name}: {message}')
+            self.sms_send_tag.value = {
+                'number': callee.sms,
+                'message': message
+            }
+            if self.status is not None:
+                self.status.value = CALLOUT
+
+    async def periodic_cb(self):
+        """Periodic callback to check alarms and send callouts."""
+        self.check_alarms()
+
+    async def start(self):
+        """Async startup."""
+        await self.busclient.start()
+        await self.periodic.start()