some core changes

Author: lu9abm

.codex

@@ -1,4 +1,4 @@
 from xlxd_dash import app
 
 if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=5000, debug=True)
+    app.run(host="0.0.0.0", port=5000, debug=False)

app.py

@@ -25,6 +25,8 @@
     "xml": "/var/log/xlxd/xlxd.xml",
     "pidfile": "/run/xlxd.pid",
     "apiURL": "http://xlxapi.rlx.lu/api.php",
+    "offline_time": 2400,
+    "ref_cache_ttl": 60,
     "callhome": false
   }
-}
+}

config_template.json

@@ -3,15 +3,20 @@
 import re
 import requests
 import json
-from datetime import datetime
+import os
+import sys
 from watchdog.observers import Observer
 from watchdog.events import FileSystemEventHandler
-import os
 import threading
 import traceback
 
+PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, PROJECT_ROOT)
+
+from xlxd_common import get_flag, normalize_xlxd_xml, parse_xlxd_datetime, read_xlxd_xml
+
 ref_name = ""
-with open("./config_tg.json", "r", encoding="utf-8") as f:
+with open(os.path.join(PROJECT_ROOT, "config_tg.json"), "r", encoding="utf-8") as f:
     config = json.load(f)
 
 modules = config["service"]["modules"]
@@ -25,9 +30,6 @@
 TG_URL = f"https://api.telegram.org/bot{config['service']['token']}/sendMessage"
 
 dt_format = "%A %a %b %d %H:%M:%S %Y"
-call_country = "./xlxd_dash/callprefix.json"
-with open(call_country, "r", encoding="utf-8") as f:
-    callprefix = json.load(f)
 
 nodes_old = {}
 nodes_off = {}
@@ -40,46 +42,51 @@
 
 def send_message(msg, dest):
     for CHAT_ID in dest:
-      data = {"chat_id": CHAT_ID, "text": msg}
-      res = requests.post(TG_URL, data=data)
-    #   print(res.text)
-
-def call_flag(country):
-    return ''.join(chr(0x1F1E6 + ord(letra) - ord('A')) for letra in country.upper())
-
-def get_flag(callsign):
-    while callsign:
-        if callsign in callprefix:
-            return call_flag(callprefix[callsign][0])
-        callsign = callsign[:-1]
-    return ""
-
-def load_xml():
-    with open(xml_file, "r", encoding="utf-8") as f:
-        XML = f.read()
+        while True:
+            data = {"chat_id": CHAT_ID, "text": msg}
+            try:
+                res = requests.post(TG_URL, data=data, timeout=10)
+            except Exception as e:
+                print(f"Error: {e}")
+                time.sleep(5)
+                continue
 
-    match = re.match(r'(<\?xml.*?\?>)', XML)
-    header = match.group(1) if match else ""
+            if res.status_code == 200:
+                break
 
-    ref_match = re.search(r"<(XLX\d+) ", XML)
-    if ref_match:
-        ref_name = ref_match.group(1)
+            print(f"Error HTTP {res.status_code}. Reintentando…")
+            time.sleep(5)
 
-    XML = XML[len(header):].strip()
+def split_node_callsign(callsign):
+    parts = callsign.split(maxsplit=1)
+    if len(parts) == 2:
+        return parts[0], parts[1]
+    return callsign, ""
 
-    XML = re.sub(r"<([\w]+)\s+([\w\s]+)>", lambda m: f"<{m.group(1)}_{m.group(2).replace(' ', '_')}>", XML)
-    XML = re.sub(r"</([\w]+)\s+([\w\s]+)>", lambda m: f"</{m.group(1)}_{m.group(2).replace(' ', '_')}>", XML)
+def format_node_call(call, initial):
+    return f"{call}-{initial}" if initial else call
 
-    XML = f"<ROOT>\n{XML}\n</ROOT>"
+def load_xml():
+    xml = read_xlxd_xml(xml_file)
+    if not xml["available"]:
+        return xml
 
-    return ref_name, XML
+    data = normalize_xlxd_xml(xml["xml"], root_name="ROOT")
+    data["available"] = True
+    return data
 
 def analizar_xml():
     global nodes_old, stations_old, notif, process, nodes_off, ref_name
     now = time.strftime("%Y%m%d_%H%M%S", time.localtime())
     now_epoch = int(time.time())
     try:
-        ref_name, XML = load_xml()
+        xml = load_xml()
+        if not xml["available"]:
+            send_message(xml["message"], logger)
+            return False
+
+        ref_name = xml["name"]
+        XML = xml["data"]
 
         if not process:
             send_message(f"REF: {ref_name}", logger)
@@ -90,15 +97,15 @@ def analizar_xml():
         nodes_now = {}
         for node in root.findall(".//NODE"):
             callsign = (node.findtext("Callsign") or "").strip()
-            call, initial = callsign.split(maxsplit=1)
+            call, initial = split_node_callsign(callsign)
             ip = (node.findtext("IP") or "").strip()
             linked_module = (node.findtext("LinkedModule") or "").strip()
             protocol = (node.findtext("Protocol") or "").strip()
             connect_time = (node.findtext("ConnectTime") or "").strip()
             last_heard_time = (node.findtext("LastHeardTime") or "").strip()
 
-            connect_time_epoch = int(datetime.strptime(connect_time, dt_format).timestamp()) if connect_time else 0
-            last_heard_time_epoch = int(datetime.strptime(last_heard_time, dt_format).timestamp()) if last_heard_time else 0
+            connect_time_epoch = parse_xlxd_datetime(connect_time)
+            last_heard_time_epoch = parse_xlxd_datetime(last_heard_time)
 
             index = (callsign + "-" + protocol or "").strip().replace(' ','_')
             if index in nodes_now.keys():
@@ -137,44 +144,47 @@ def analizar_xml():
                 for key in nuevos:
                     Call = nodes_now[key]["Call"]
                     Initial = nodes_now[key]["Initial"]
+                    NodeCall = format_node_call(Call, Initial)
                     LinkedModule = nodes_now[key]["LinkedModule"]
                     Protocol = nodes_now[key]["Protocol"]
                     flag = get_flag(Call)
                     if key in nodes_off.keys():
                         del nodes_off[key]
-                        send_message(f"Online {Call}-{Initial} On {ref_name} {LinkedModule} Protocol {Protocol}", logger)
+                        send_message(f"Online {NodeCall} On {ref_name} {LinkedModule} Protocol {Protocol}", logger)
                     else:
                         if (LinkedModule in modules):
                             notifto = logger + node_offline
                         else:
                             notifto = logger
 
-                        send_message(f"✅{flag} {Call}-{Initial} On {ref_name} {LinkedModule} Protocol {Protocol}", notifto)
+                        send_message(f"✅{flag} {NodeCall} On {ref_name} {LinkedModule} Protocol {Protocol}", notifto)
 
             ### NODES - si faltan nodes que antes estaban (old - now)
             eliminados = nodes_old.keys() - nodes_now.keys()
             if eliminados:
                 for key in eliminados:
                     Call = nodes_old[key]["Call"]
                     Initial = nodes_old[key]["Initial"]
+                    NodeCall = format_node_call(Call, Initial)
                     LinkedModule = nodes_old[key]["LinkedModule"]
                     Protocol = nodes_old[key]["Protocol"]
-                    send_message(f"Offline {Call}-{Initial} From {ref_name} {LinkedModule} Protocol {Protocol}", logger)
+                    send_message(f"Offline {NodeCall} From {ref_name} {LinkedModule} Protocol {Protocol}", logger)
                     nodes_off[key] = nodes_old[key]
                     nodes_off[key]["last_off"] = now_epoch
 
             for key in list(nodes_off.keys()):
                 if nodes_off[key]["last_off"] + node_delay < now_epoch:
                     Call = nodes_off[key]["Call"]
                     Initial = nodes_off[key]["Initial"]
+                    NodeCall = format_node_call(Call, Initial)
                     LinkedModule = nodes_off[key]["LinkedModule"]
                     Protocol = nodes_off[key]["Protocol"]
                     flag = get_flag(Call)
                     if (LinkedModule in modules):
                         notifto = logger + node_offline
                     else:
                         notifto = logger
-                    send_message(f"❌{flag} {Call}-{Initial} From {ref_name} {LinkedModule} Protocol {Protocol}", notifto)
+                    send_message(f"❌{flag} {NodeCall} From {ref_name} {LinkedModule} Protocol {Protocol}", notifto)
 
                     del nodes_off[key]
 
@@ -193,7 +203,7 @@ def analizar_xml():
             via_peer = (station.findtext("Via_peer") or "").strip()
             last_heard_time = (station.findtext("LastHeardTime") or "").strip()
 
-            last_heard_time_epoch = int(datetime.strptime(last_heard_time, dt_format).timestamp()) if last_heard_time else 0
+            last_heard_time_epoch = parse_xlxd_datetime(last_heard_time)
 
             index = (callsign or "").strip().replace(' ', '_')
 
@@ -287,4 +297,5 @@ def INITmonitor():
         process = analizar_xml()
         if process:
             INITmonitor()
-            time.sleep(1)
+        else:
+            time.sleep(30)

telegram/telegram.py

@@ -0,0 +1,111 @@
+import json
+import os
+import re
+import fcntl
+from datetime import datetime
+
+
+DT_FORMAT = "%A %a %b %d %H:%M:%S %Y"
+CALLPREFIX_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "xlxd_dash", "callprefix.json")
+
+with open(CALLPREFIX_PATH, "r", encoding="utf-8") as f:
+    CALLPREFIX = json.load(f)
+
+
+def read_xlxd_xml(xml_file):
+    if not os.path.exists(xml_file):
+        return {
+            "available": False,
+            "message": "XLXD data is not available yet.",
+            "detail": f"XML file not found: {xml_file}",
+        }
+
+    try:
+        with open(xml_file, "r", encoding="utf-8") as f:
+            try:
+                fcntl.flock(f, fcntl.LOCK_SH | fcntl.LOCK_NB)
+            except BlockingIOError:
+                return {
+                    "available": False,
+                    "message": "XLXD data is being updated.",
+                    "detail": f"XML file is locked: {xml_file}",
+                }
+
+            return {"available": True, "xml": f.read()}
+    except Exception as e:
+        return {
+            "available": False,
+            "message": "XLXD data could not be read.",
+            "detail": str(e),
+        }
+
+
+def normalize_xlxd_xml(xml_text, root_name="DATA"):
+    ref_name = ""
+    match = re.match(r"(<\?xml.*?\?>)", xml_text)
+    header = match.group(1) if match else ""
+
+    ref_match = re.search(r"<(XLX[\w\d]{3}) ", xml_text)
+    if ref_match:
+        ref_name = ref_match.group(1)
+
+    xml_text = xml_text[len(header):].strip()
+    xml_text = re.sub(
+        r"<([\w]+)\s+([\w\s]+)>",
+        lambda m: f"<{m.group(1)}_{m.group(2).replace(' ', '_')}>",
+        xml_text,
+    )
+    xml_text = re.sub(
+        r"</([\w]+)\s+([\w\s]+)>",
+        lambda m: f"</{m.group(1)}_{m.group(2).replace(' ', '_')}>",
+        xml_text,
+    )
+
+    return {"name": ref_name, "data": f"<{root_name}>\n{xml_text}\n</{root_name}>"}
+
+
+def parse_xlxd_datetime(value):
+    if not value:
+        return 0
+    return int(datetime.strptime(value, DT_FORMAT).timestamp())
+
+
+def call_flag(country):
+    return "".join(chr(0x1F1E6 + ord(letter) - ord("A")) for letter in country.upper())
+
+
+def get_flag_info(callsign):
+    while callsign:
+        if callsign in CALLPREFIX:
+            return [call_flag(CALLPREFIX[callsign][0]), CALLPREFIX[callsign][1]]
+        callsign = callsign[:-1]
+    return ["", ""]
+
+
+def get_flag(callsign):
+    return get_flag_info(callsign)[0]
+
+
+def mask_ip(ip, mask):
+    if mask == 0:
+        return False
+    return ".".join(ip.split(".")[:mask] + ["?"] * (4 - mask))
+
+
+def as_list(value):
+    if not value:
+        return []
+    if isinstance(value, list):
+        return value
+    return [value]
+
+
+def safe_int(value, default=0):
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return default
+
+
+def is_online(last_contact, now, offline_time):
+    return safe_int(last_contact) > now - safe_int(offline_time, 2400)

xlxd_common.py

@@ -8,13 +8,13 @@ def run_checks():
     if not bool(re.fullmatch(r"XLX[A-Z0-9]{3}", config["service"]["name"])):
         raise SystemExit(f"XLX name not set or invalid\nCheck GitHub page for more information.")
 
-    checkfiles = [
-        config["xlxd"]["pidfile"],
-        config["xlxd"]["xml"],
-    ]
-    for file in checkfiles:
-        if not Path(file).exists():
-            raise SystemExit(f"Error reading file {file}\nCheck GitHub page for more information.")
+    pid_file = config["xlxd"]["pidfile"]
+    if not Path(pid_file).exists():
+        print(f"Warning: PID file not found: {pid_file}")
+
+    xml_file = config["xlxd"]["xml"]
+    if not Path(xml_file).exists():
+        print(f"Warning: XML file not found yet: {xml_file}")
 
     if config["xlxd"]["callhome"] == True:
         print("Startup callhome...")