533 lines
18 KiB
Python
533 lines
18 KiB
Python
"""
|
||
Thor Watcher — System Tray Launcher v0.2.0
|
||
Requires: pystray, Pillow, tkinter (stdlib)
|
||
|
||
Run with: pythonw thor_tray.py (no console window)
|
||
or: python thor_tray.py (with console, for debugging)
|
||
|
||
Put a shortcut to this in shell:startup for auto-start on login.
|
||
"""
|
||
|
||
import os
|
||
import sys
|
||
import json
|
||
import subprocess
|
||
import tempfile
|
||
import threading
|
||
import urllib.request
|
||
import urllib.error
|
||
from datetime import datetime
|
||
|
||
import pystray
|
||
from PIL import Image, ImageDraw
|
||
|
||
import series4_ingest as watcher
|
||
|
||
|
||
# ── Auto-updater ──────────────────────────────────────────────────────────────
|
||
|
||
GITEA_BASE = "https://gitea.serversdown.net"
|
||
GITEA_USER = "serversdown"
|
||
GITEA_REPO = "thor-watcher"
|
||
GITEA_API_URL = "{}/api/v1/repos/{}/{}/releases?limit=1&page=1".format(
|
||
GITEA_BASE, GITEA_USER, GITEA_REPO
|
||
)
|
||
|
||
_CURRENT_VERSION = getattr(watcher, "VERSION", "0.0.0")
|
||
|
||
|
||
def _version_tuple(v):
|
||
"""Convert '0.2.0' -> (0, 2, 0) for comparison."""
|
||
parts = []
|
||
for p in str(v).lstrip("v").split(".")[:3]:
|
||
try:
|
||
parts.append(int(p))
|
||
except ValueError:
|
||
parts.append(0)
|
||
while len(parts) < 3:
|
||
parts.append(0)
|
||
return tuple(parts)
|
||
|
||
|
||
def _update_log(msg):
|
||
"""Append a timestamped [updater] line to the watcher log."""
|
||
try:
|
||
log_path = os.path.join(
|
||
os.environ.get("LOCALAPPDATA") or os.environ.get("APPDATA") or "",
|
||
"ThorWatcher", "agent_logs", "thor_watcher.log"
|
||
)
|
||
os.makedirs(os.path.dirname(log_path), exist_ok=True)
|
||
with open(log_path, "a") as f:
|
||
f.write("[{}] [updater] {}\n".format(
|
||
datetime.now().strftime("%Y-%m-%d %H:%M:%S"), msg
|
||
))
|
||
except Exception:
|
||
pass
|
||
|
||
|
||
def _check_for_update_gitea():
|
||
"""Query Gitea API for latest release. Returns (tag, download_url) or (None, None)."""
|
||
try:
|
||
req = urllib.request.Request(
|
||
GITEA_API_URL,
|
||
headers={"User-Agent": "thor-watcher/{}".format(_CURRENT_VERSION)},
|
||
)
|
||
with urllib.request.urlopen(req, timeout=8) as resp:
|
||
releases = json.loads(resp.read().decode("utf-8"))
|
||
if not releases:
|
||
return None, None
|
||
latest = releases[0]
|
||
tag = latest.get("tag_name", "")
|
||
if _version_tuple(tag) <= _version_tuple(_CURRENT_VERSION):
|
||
return None, None
|
||
assets = latest.get("assets", [])
|
||
for asset in assets:
|
||
name = asset.get("name", "").lower()
|
||
if name.endswith(".exe") and "setup" not in name:
|
||
return tag, asset.get("browser_download_url")
|
||
_update_log("Newer release {} found but no valid .exe asset".format(tag))
|
||
return tag, None
|
||
except Exception as e:
|
||
_update_log("check_for_update (gitea) failed: {}".format(e))
|
||
return None, None
|
||
|
||
|
||
def _check_for_update_url(base_url):
|
||
"""Query a custom URL server for latest version. Returns (tag, download_url) or (None, None)."""
|
||
if not base_url:
|
||
_update_log("update_source=url but update_url is empty — skipping")
|
||
return None, None
|
||
try:
|
||
ver_url = base_url.rstrip("/") + "/api/updates/thor-watcher/version.txt"
|
||
req = urllib.request.Request(
|
||
ver_url,
|
||
headers={"User-Agent": "thor-watcher/{}".format(_CURRENT_VERSION)},
|
||
)
|
||
with urllib.request.urlopen(req, timeout=8) as resp:
|
||
tag = resp.read().decode("utf-8").strip()
|
||
if not tag:
|
||
return None, None
|
||
if _version_tuple(tag) <= _version_tuple(_CURRENT_VERSION):
|
||
return None, None
|
||
exe_url = base_url.rstrip("/") + "/api/updates/thor-watcher/thor-watcher.exe"
|
||
return tag, exe_url
|
||
except Exception as e:
|
||
_update_log("check_for_update (url mode) failed: {}".format(e))
|
||
return None, None
|
||
|
||
|
||
def check_for_update():
|
||
"""
|
||
Check for an update using the configured source (gitea, url, or disabled).
|
||
Reads update_source and update_url from config.json at check time.
|
||
Returns (tag, download_url) if an update is available, else (None, None).
|
||
"""
|
||
try:
|
||
cfg = _read_config()
|
||
update_source = str(cfg.get("update_source", "gitea")).strip().lower()
|
||
update_url = str(cfg.get("update_url", "")).strip()
|
||
except Exception:
|
||
update_source = "gitea"
|
||
update_url = ""
|
||
|
||
if update_source == "disabled":
|
||
return None, None
|
||
|
||
_update_log("Checking for update (source={}, version={})".format(
|
||
update_source, _CURRENT_VERSION
|
||
))
|
||
|
||
if update_source == "url":
|
||
return _check_for_update_url(update_url)
|
||
else:
|
||
return _check_for_update_gitea()
|
||
|
||
|
||
def apply_update(download_url):
|
||
"""
|
||
Download new .exe, validate it, write swap .bat, launch it, exit.
|
||
Backs up old exe to .exe.old before replacing.
|
||
"""
|
||
exe_path = os.path.abspath(sys.executable if getattr(sys, "frozen", False) else sys.argv[0])
|
||
|
||
try:
|
||
tmp_fd, tmp_path = tempfile.mkstemp(suffix=".exe", prefix="tw_update_")
|
||
os.close(tmp_fd)
|
||
|
||
_update_log("Downloading update from: {}".format(download_url))
|
||
|
||
req = urllib.request.Request(
|
||
download_url,
|
||
headers={"User-Agent": "thor-watcher/{}".format(_CURRENT_VERSION)},
|
||
)
|
||
with urllib.request.urlopen(req, timeout=60) as resp:
|
||
with open(tmp_path, "wb") as f:
|
||
f.write(resp.read())
|
||
|
||
# Three-layer validation
|
||
try:
|
||
dl_size = os.path.getsize(tmp_path)
|
||
current_size = os.path.getsize(exe_path)
|
||
_update_log("Download complete ({} bytes), validating...".format(dl_size))
|
||
|
||
if dl_size < 100 * 1024:
|
||
_update_log("Validation failed: too small ({} bytes) — aborting".format(dl_size))
|
||
os.remove(tmp_path)
|
||
return False
|
||
|
||
if current_size > 0 and dl_size < current_size * 0.5:
|
||
_update_log("Validation failed: suspiciously small ({} vs {} bytes) — aborting".format(
|
||
dl_size, current_size))
|
||
os.remove(tmp_path)
|
||
return False
|
||
|
||
with open(tmp_path, "rb") as _f:
|
||
magic = _f.read(2)
|
||
if magic != b"MZ":
|
||
_update_log("Validation failed: not a valid Windows exe — aborting")
|
||
os.remove(tmp_path)
|
||
return False
|
||
|
||
_update_log("Validation passed ({} bytes, MZ ok)".format(dl_size))
|
||
|
||
except Exception as e:
|
||
_update_log("Validation error: {} — aborting".format(e))
|
||
try:
|
||
os.remove(tmp_path)
|
||
except Exception:
|
||
pass
|
||
return False
|
||
|
||
bat_fd, bat_path = tempfile.mkstemp(suffix=".bat", prefix="tw_swap_")
|
||
os.close(bat_fd)
|
||
|
||
bat_content = (
|
||
"@echo off\r\n"
|
||
"ping 127.0.0.1 -n 4 > nul\r\n"
|
||
"copy /Y \"{exe}\" \"{exe}.old\"\r\n"
|
||
"set RETRIES=0\r\n"
|
||
":retry\r\n"
|
||
"copy /Y \"{new}\" \"{exe}\"\r\n"
|
||
"if errorlevel 1 (\r\n"
|
||
" set /a RETRIES+=1\r\n"
|
||
" if %RETRIES% GEQ 5 goto fail\r\n"
|
||
" ping 127.0.0.1 -n 3 > nul\r\n"
|
||
" goto retry\r\n"
|
||
")\r\n"
|
||
"start \"\" \"{exe}\"\r\n"
|
||
"del \"{new}\"\r\n"
|
||
"del \"%~f0\"\r\n"
|
||
"exit /b 0\r\n"
|
||
":fail\r\n"
|
||
"del \"{new}\"\r\n"
|
||
"del \"%~f0\"\r\n"
|
||
"exit /b 1\r\n"
|
||
).format(new=tmp_path, exe=exe_path)
|
||
|
||
with open(bat_path, "w") as f:
|
||
f.write(bat_content)
|
||
|
||
_update_log("Launching swap bat — exiting for update")
|
||
|
||
subprocess.Popen(
|
||
["cmd", "/C", bat_path],
|
||
creationflags=subprocess.CREATE_NO_WINDOW if hasattr(subprocess, "CREATE_NO_WINDOW") else 0,
|
||
)
|
||
return True
|
||
|
||
except Exception as e:
|
||
_update_log("apply_update failed: {}".format(e))
|
||
return False
|
||
|
||
|
||
# ── Config helpers ────────────────────────────────────────────────────────────
|
||
|
||
def _read_config():
|
||
"""Read config.json from the appropriate location and return as dict."""
|
||
if getattr(sys, "frozen", False):
|
||
_appdata = os.environ.get("LOCALAPPDATA") or os.environ.get("APPDATA") or ""
|
||
config_dir = os.path.join(_appdata, "ThorWatcher")
|
||
else:
|
||
config_dir = os.path.dirname(os.path.abspath(__file__)) or "."
|
||
config_path = os.path.join(config_dir, "config.json")
|
||
with open(config_path, "r", encoding="utf-8") as f:
|
||
return json.load(f)
|
||
|
||
|
||
# ── Paths ─────────────────────────────────────────────────────────────────────
|
||
|
||
if getattr(sys, "frozen", False):
|
||
HERE = os.path.dirname(os.path.abspath(sys.executable))
|
||
else:
|
||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||
|
||
if getattr(sys, "frozen", False):
|
||
_appdata = os.environ.get("LOCALAPPDATA") or os.environ.get("APPDATA") or HERE
|
||
CONFIG_DIR = os.path.join(_appdata, "ThorWatcher")
|
||
os.makedirs(CONFIG_DIR, exist_ok=True)
|
||
else:
|
||
CONFIG_DIR = HERE
|
||
CONFIG_PATH = os.path.join(CONFIG_DIR, "config.json")
|
||
|
||
|
||
# ── Icon drawing ──────────────────────────────────────────────────────────────
|
||
|
||
COLORS = {
|
||
"ok": (60, 200, 80), # green
|
||
"pending": (230, 180, 0), # amber
|
||
"missing": (210, 40, 40), # red
|
||
"error": (160, 40, 200), # purple
|
||
"starting": (120, 120, 120), # grey
|
||
}
|
||
|
||
ICON_SIZE = 64
|
||
|
||
|
||
def make_icon(status):
|
||
"""Draw a plain colored circle for the system tray."""
|
||
color = COLORS.get(status, COLORS["starting"])
|
||
img = Image.new("RGBA", (ICON_SIZE, ICON_SIZE), (0, 0, 0, 0))
|
||
draw = ImageDraw.Draw(img)
|
||
margin = 6
|
||
draw.ellipse(
|
||
[margin, margin, ICON_SIZE - margin, ICON_SIZE - margin],
|
||
fill=color,
|
||
)
|
||
return img
|
||
|
||
|
||
# ── First-run check ───────────────────────────────────────────────────────────
|
||
|
||
def ensure_config():
|
||
"""
|
||
If config.json is missing, launch the first-run wizard.
|
||
Returns True if config is ready, False if user cancelled.
|
||
"""
|
||
if os.path.exists(CONFIG_PATH):
|
||
return True
|
||
|
||
from thor_settings_dialog import show_dialog
|
||
saved = show_dialog(CONFIG_PATH, wizard=True)
|
||
if not saved:
|
||
_show_cancel_message()
|
||
return False
|
||
return True
|
||
|
||
|
||
def _show_cancel_message():
|
||
try:
|
||
import tkinter as tk
|
||
from tkinter import messagebox
|
||
root = tk.Tk()
|
||
root.withdraw()
|
||
messagebox.showwarning(
|
||
"Thor Watcher",
|
||
"No configuration was saved.\nThe application will now exit.",
|
||
)
|
||
root.destroy()
|
||
except Exception:
|
||
pass
|
||
|
||
|
||
# ── Tray app ──────────────────────────────────────────────────────────────────
|
||
|
||
class WatcherTray:
|
||
def __init__(self):
|
||
self.state = {}
|
||
self.stop_event = threading.Event()
|
||
self._watcher_thread = None
|
||
self._icon = None
|
||
self._menu_lock = threading.Lock()
|
||
|
||
# ── Watcher thread management ─────────────────────────────────────────────
|
||
|
||
def _start_watcher(self):
|
||
self.stop_event.clear()
|
||
self._watcher_thread = threading.Thread(
|
||
target=watcher.run_watcher,
|
||
args=(self.state, self.stop_event),
|
||
daemon=True,
|
||
name="watcher",
|
||
)
|
||
self._watcher_thread.start()
|
||
|
||
def _stop_watcher(self):
|
||
self.stop_event.set()
|
||
if self._watcher_thread is not None:
|
||
self._watcher_thread.join(timeout=10)
|
||
self._watcher_thread = None
|
||
|
||
def _restart_watcher(self):
|
||
self._stop_watcher()
|
||
self.stop_event = threading.Event()
|
||
self.state["status"] = "starting"
|
||
self.state["units"] = []
|
||
self.state["last_scan"] = None
|
||
self.state["last_error"] = None
|
||
self._start_watcher()
|
||
|
||
# ── Menu callbacks ────────────────────────────────────────────────────────
|
||
|
||
def _open_settings(self, icon, item):
|
||
def _run():
|
||
from thor_settings_dialog import show_dialog
|
||
saved = show_dialog(CONFIG_PATH, wizard=False)
|
||
if saved:
|
||
self._restart_watcher()
|
||
threading.Thread(target=_run, daemon=True, name="settings-dialog").start()
|
||
|
||
def _open_logs(self, icon, item):
|
||
log_dir = self.state.get("log_dir")
|
||
if not log_dir:
|
||
log_dir = HERE
|
||
if os.path.exists(log_dir):
|
||
subprocess.Popen(["explorer", log_dir])
|
||
else:
|
||
parent = os.path.dirname(log_dir)
|
||
if os.path.exists(parent):
|
||
subprocess.Popen(["explorer", parent])
|
||
else:
|
||
subprocess.Popen(["explorer", HERE])
|
||
|
||
def _exit(self, icon, item):
|
||
self.stop_event.set()
|
||
icon.stop()
|
||
|
||
# ── Dynamic menu text ─────────────────────────────────────────────────────
|
||
|
||
def _status_text(self):
|
||
status = self.state.get("status", "starting")
|
||
last_err = self.state.get("last_error")
|
||
last_scan = self.state.get("last_scan")
|
||
api_status = self.state.get("api_status", "disabled")
|
||
unit_count = len(self.state.get("units", []))
|
||
|
||
if status == "error":
|
||
return "Error — {}".format(last_err or "unknown")
|
||
if status == "starting":
|
||
return "Starting..."
|
||
|
||
if last_scan is not None:
|
||
age_secs = int((datetime.now() - last_scan).total_seconds())
|
||
age_str = "{}s ago".format(age_secs) if age_secs < 60 else "{}m ago".format(age_secs // 60)
|
||
else:
|
||
age_str = "never"
|
||
|
||
if api_status == "ok":
|
||
api_str = "API OK"
|
||
elif api_status == "fail":
|
||
api_str = "API FAIL"
|
||
else:
|
||
api_str = "API off"
|
||
|
||
return "Running — {} | {} unit(s) | scan {}".format(api_str, unit_count, age_str)
|
||
|
||
def _tray_status(self):
|
||
status = self.state.get("status", "starting")
|
||
if status == "error":
|
||
return "error"
|
||
if status == "starting":
|
||
return "starting"
|
||
api_status = self.state.get("api_status", "disabled")
|
||
if api_status == "fail":
|
||
return "missing" # red — API failing
|
||
if api_status == "disabled":
|
||
return "pending" # amber — running but not reporting
|
||
return "ok" # green — running and API good
|
||
|
||
def _build_menu(self):
|
||
return pystray.Menu(
|
||
pystray.MenuItem(lambda item: self._status_text(), None, enabled=False),
|
||
pystray.Menu.SEPARATOR,
|
||
pystray.MenuItem("Settings...", self._open_settings),
|
||
pystray.MenuItem("Open Log Folder", self._open_logs),
|
||
pystray.Menu.SEPARATOR,
|
||
pystray.MenuItem("Exit", self._exit),
|
||
)
|
||
|
||
# ── Icon/menu update loop ─────────────────────────────────────────────────
|
||
|
||
def _icon_updater(self):
|
||
"""Periodically refresh the tray icon and check for updates."""
|
||
last_status = None
|
||
update_check_counter = 0 # check every ~5 min (30 × 10s ticks)
|
||
|
||
while not self.stop_event.is_set():
|
||
icon_status = self._tray_status()
|
||
|
||
if self._icon is not None:
|
||
with self._menu_lock:
|
||
self._icon.menu = self._build_menu()
|
||
if icon_status != last_status:
|
||
self._icon.icon = make_icon(icon_status)
|
||
self._icon.title = "Thor Watcher — {}".format(self._status_text())
|
||
last_status = icon_status
|
||
|
||
# Terra-View push-triggered update
|
||
if self.state.get("update_available"):
|
||
self.state["update_available"] = False
|
||
self._do_update()
|
||
return
|
||
|
||
# Periodic update check
|
||
update_check_counter += 1
|
||
if update_check_counter >= 30:
|
||
update_check_counter = 0
|
||
tag, url = check_for_update()
|
||
if tag and url:
|
||
self._do_update(url)
|
||
return
|
||
|
||
self.stop_event.wait(timeout=10)
|
||
|
||
def _do_update(self, download_url=None):
|
||
"""Notify tray then apply update. If url is None, fetch it first."""
|
||
if download_url is None:
|
||
_, download_url = check_for_update()
|
||
if not download_url:
|
||
return
|
||
|
||
if self._icon is not None:
|
||
self._icon.title = "Thor Watcher — Updating..."
|
||
self._icon.icon = make_icon("starting")
|
||
|
||
success = apply_update(download_url)
|
||
if success:
|
||
self.stop_event.set()
|
||
if self._icon is not None:
|
||
self._icon.stop()
|
||
|
||
# ── Entry point ───────────────────────────────────────────────────────────
|
||
|
||
def run(self):
|
||
self._start_watcher()
|
||
|
||
icon_img = make_icon("starting")
|
||
self._icon = pystray.Icon(
|
||
name="thor_watcher",
|
||
icon=icon_img,
|
||
title="Thor Watcher — Starting...",
|
||
menu=self._build_menu(),
|
||
)
|
||
|
||
updater = threading.Thread(
|
||
target=self._icon_updater, daemon=True, name="icon-updater"
|
||
)
|
||
updater.start()
|
||
|
||
self._icon.run()
|
||
|
||
|
||
# ── Entry point ───────────────────────────────────────────────────────────────
|
||
|
||
def main():
|
||
if not ensure_config():
|
||
sys.exit(0)
|
||
|
||
app = WatcherTray()
|
||
app.run()
|
||
|
||
|
||
if __name__ == "__main__":
|
||
main()
|