serverwatcher 4.0.1__tar.gz → 4.2__tar.gz

{serverwatcher-4.0.1/src/serverwatcher.egg-info → serverwatcher-4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: serverwatcher
-Version: 4.0.1
+Version: 4.2
 Summary: A HungerLib-powered Minecraft server automation engine.
 Author: iFamished
 License: GPL-3.0

{serverwatcher-4.0.1 → serverwatcher-4.2}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "serverwatcher"
-version = "4.0.1"
+version = "4.2"
 description = "A HungerLib-powered Minecraft server automation engine."
 readme = "README.md"
 requires-python = ">=3.10"

serverwatcher-4.2/src/serverwatcher/autorepair.py

@@ -0,0 +1,137 @@
+import os
+import yaml
+from dataclasses import fields, MISSING
+
+from hungerlib.addons import load_yaml, flatten_nested
+from serverwatcher.configclasses.global_config import GlobalConfig
+from serverwatcher.configclasses.messages import MessagesConfig
+from serverwatcher.configclasses.watcher import WatcherConfig
+
+
+# ---------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------
+
+def load_yaml_default(schema, default_path):
+    """
+    Load the default YAML file located inside the schema's package.
+    """
+    module_file = schema.__module__.replace(".", "/")
+    pkg_root = os.path.dirname(os.path.dirname(__import__(schema.__module__).__file__))
+    abs_default = os.path.join(pkg_root, default_path.lstrip("/"))
+
+    if os.path.exists(abs_default):
+        return flatten_nested(load_yaml(abs_default))
+    return {}
+
+
+def get_schema_defaults(schema):
+    """
+    Extract default values from dataclass fields.
+    """
+    defaults = {}
+    for f in fields(schema):
+        if f.default is not MISSING:
+            defaults[f.name] = f.default
+        elif f.default_factory is not MISSING:  # type: ignore
+            defaults[f.name] = f.default_factory()  # type: ignore
+    return defaults
+
+
+def repair_value(name, value, expected_type, schema_defaults, yaml_defaults, repairs):
+    """
+    Determine the correct value for a field using priority:
+    1. User value (if valid)
+    2. Schema default
+    3. YAML default
+    """
+    # If value is correct type and valid, keep it
+    if isinstance(value, expected_type):
+        if expected_type in (int, float) and value < 0:
+            repairs.append(f"{name}: negative → repaired to default")
+        else:
+            return value
+
+    # Try schema default
+    if name in schema_defaults:
+        repairs.append(f"{name}: repaired using schema default")
+        return schema_defaults[name]
+
+    # Try YAML default
+    if name in yaml_defaults:
+        repairs.append(f"{name}: repaired using YAML default")
+        return yaml_defaults[name]
+
+    # Fallback: empty string or zero
+    repairs.append(f"{name}: no defaults found → set to safe fallback")
+    if expected_type is str:
+        return ""
+    if expected_type in (int, float):
+        return 0
+    return None
+
+
+def repair_config(path, default_path, schema):
+    """
+    Load, repair, and rewrite a config file.
+    """
+    print(f"\n🔧 Repairing {path}...")
+
+    # Load user config (raw YAML)
+    if os.path.exists(path):
+        raw = flatten_nested(load_yaml(path))
+    else:
+        raw = {}
+
+    # Load defaults
+    schema_defaults = get_schema_defaults(schema)
+    yaml_defaults = load_yaml_default(schema, default_path)
+
+    repaired = {}
+    repairs = []
+
+    # Validate each field in schema
+    for f in fields(schema):
+        name = f.name
+        expected_type = f.type
+        value = raw.get(name, None)
+
+        repaired[name] = repair_value(
+            name, value, expected_type, schema_defaults, yaml_defaults, repairs
+        )
+
+    # Write repaired YAML back to disk
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "w") as f:
+        yaml.dump(repaired, f, sort_keys=False)
+
+    if repairs:
+        print("  ✔ Repairs applied:")
+        for r in repairs:
+            print("    -", r)
+    else:
+        print("  ✔ No repairs needed")
+
+    return repairs
+
+
+# ---------------------------------------------------------
+# Main
+# ---------------------------------------------------------
+
+def autorepair_all():
+    print("=== ServerWatcher Auto‑Repair ===")
+
+    repairs = []
+    repairs += repair_config("config/global.yaml", "/defaultconfigs/global.yaml", GlobalConfig)
+    repairs += repair_config("config/messages.yaml", "/defaultconfigs/messages.yaml", MessagesConfig)
+    repairs += repair_config("config/watcher.yaml", "/defaultconfigs/watcher.yaml", WatcherConfig)
+
+    if repairs:
+        print("\n✅ Auto‑repair completed with fixes.")
+    else:
+        print("\n✅ All configs already valid — no repairs needed.")
+
+
+if __name__ == "__main__":
+    autorepair_all()

{serverwatcher-4.0.1 → serverwatcher-4.2}/src/serverwatcher/configclasses/global_config.py

@@ -2,6 +2,8 @@ from dataclasses import dataclass
 
 @dataclass
 class GlobalConfig:
+    watch_interval: int
+
     panel_name: str
     panel_url: str
     panel_api_key: str
@@ -15,3 +17,11 @@ class GlobalConfig:
     rcon_port: int
     rcon_password: str
     tps_command: str
+    
+    do_logging: bool
+    logger_name: str
+    log_path: str
+    timezone: str
+
+    console_backspaces: int
+    clear_terminal: bool

{serverwatcher-4.0.1 → serverwatcher-4.2}/src/serverwatcher/configclasses/watcher.py

@@ -24,13 +24,4 @@ class WatcherConfig:
 
     restart_wait_seconds: int
     restart_online_timeout: int
-    restart_online_interval: int
-
-    logger_name_template: str
-    log_path: str
-    console_backspaces: int
-    timezone: str
-
-    # New values (will reorder later)
-    watch_interval: int
-    clear_terminal: bool
+    restart_online_interval: int

{serverwatcher-4.0.1 → serverwatcher-4.2}/src/serverwatcher/defaultconfigs/global.yaml

@@ -1,3 +1,5 @@
+watch_interval: 60
+
 panel:
   panel_name: My Panel
   panel_url: https://example.com
@@ -14,3 +16,13 @@ server:
   rcon_port: 25575
   rcon_password: password
   tps_command: ticks
+
+logging:
+  do_logging: True
+  logger_name: "Server Watcher"
+  log_path: "/home/container/logs/"
+  timezone: "America/Chicago"
+
+terminal:
+  console_backspaces: 8
+  clear_terminal: True

{serverwatcher-4.0.1 → serverwatcher-4.2}/src/serverwatcher/defaultconfigs/watcher.yaml

@@ -1,12 +1,3 @@
-logging:
-  logger_name_template: "Server Watcher"
-  log_path: "/home/container/logs/"
-  timezone: "America/Chicago"
-
-terminal_settings:
-  console_backspaces: 8
-  clear_terminal: True
-
 schedules:
   restart_soon_schedule_id: 0     # replace this with real schedule id
   origin_disable_schedule_id: 0   # replace this with real schedule id
@@ -33,7 +24,4 @@ gaps:
 restart_intervals:
   restart_wait_seconds: 45
   restart_online_timeout: 120
-  restart_online_interval: 2
-
-watcher_intervals:
-  watch_interval: 60 
+  restart_online_interval: 2

serverwatcher-4.2/src/serverwatcher/validation.py

@@ -0,0 +1,125 @@
+import sys
+from dataclasses import fields
+
+from hungerlib.addons.simpleloader import loadConfig
+
+from serverwatcher.configclasses.global_config import GlobalConfig
+from serverwatcher.configclasses.messages import MessagesConfig
+from serverwatcher.configclasses.watcher import WatcherConfig
+
+
+# -----------------------------
+# Generic validation helpers
+# -----------------------------
+
+def validate_type(name, value, expected_type, errors):
+    if not isinstance(value, expected_type):
+        errors.append(f"{name}: expected {expected_type.__name__}, got {type(value).__name__}")
+
+
+def validate_positive(name, value, errors):
+    if isinstance(value, (int, float)) and value < 0:
+        errors.append(f"{name}: must be >= 0 (got {value})")
+
+
+def validate_nonempty(name, value, errors):
+    if isinstance(value, str) and value.strip() == "":
+        errors.append(f"{name}: cannot be empty")
+
+
+def validate_dataclass(config_obj, schema, errors):
+    """
+    Validate all fields in a dataclass:
+    - type correctness
+    - non-negative numbers
+    - non-empty strings
+    """
+    for f in fields(schema):
+        name = f.name
+        expected_type = f.type
+        value = getattr(config_obj, name)
+
+        # Type check
+        validate_type(name, value, expected_type, errors)
+
+        # String checks
+        if expected_type is str:
+            validate_nonempty(name, value, errors)
+
+        # Numeric checks
+        if expected_type in (int, float):
+            validate_positive(name, value, errors)
+
+
+# -----------------------------
+# Config-specific validation
+# -----------------------------
+
+def validate_global_config(cfg, errors):
+    # Example: ensure ports are valid
+    if cfg.server_port <= 0 or cfg.server_port > 65535:
+        errors.append(f"server_port: must be 1–65535 (got {cfg.server_port})")
+
+    if cfg.rcon_port <= 0 or cfg.rcon_port > 65535:
+        errors.append(f"rcon_port: must be 1–65535 (got {cfg.rcon_port})")
+
+
+def validate_watcher_config(cfg, errors):
+    if cfg.watch_interval < 1:
+        errors.append(f"watch_interval: must be >= 1 (got {cfg.watch_interval})")
+
+    if cfg.restart_wait_seconds < 1:
+        errors.append(f"restart_wait_seconds: must be >= 1 (got {cfg.restart_wait_seconds})")
+
+    if cfg.cpu_threshold <= 0 or cfg.cpu_threshold > 100:
+        errors.append(f"cpu_threshold: must be 1–100 (got {cfg.cpu_threshold})")
+
+    if cfg.ram_threshold <= 0:
+        errors.append(f"ram_threshold: must be > 0 (got {cfg.ram_threshold})")
+
+    if cfg.tps_threshold <= 0 or cfg.tps_threshold > 20:
+        errors.append(f"tps_threshold: must be 1–20 (got {cfg.tps_threshold})")
+
+
+def validate_messages_config(cfg, errors):
+    # Ensure all message templates contain {prefix}
+    for name, value in vars(cfg).items():
+        if isinstance(value, str) and "{prefix}" not in value:
+            # Not required for every field, but warn if missing
+            pass
+
+
+# -----------------------------
+# Main validator
+# -----------------------------
+
+def validate_all():
+    errors = []
+
+    # Load configs
+    global_cfg = loadConfig("config/global.yaml", "/defaultconfigs/global.yaml", GlobalConfig)
+    messages_cfg = loadConfig("config/messages.yaml", "/defaultconfigs/messages.yaml", MessagesConfig)
+    watcher_cfg = loadConfig("config/watcher.yaml", "/defaultconfigs/watcher.yaml", WatcherConfig)
+
+    # Generic dataclass validation
+    validate_dataclass(global_cfg, GlobalConfig, errors)
+    validate_dataclass(messages_cfg, MessagesConfig, errors)
+    validate_dataclass(watcher_cfg, WatcherConfig, errors)
+
+    # Config-specific validation
+    validate_global_config(global_cfg, errors)
+    validate_messages_config(messages_cfg, errors)
+    validate_watcher_config(watcher_cfg, errors)
+
+    # Print results
+    if errors:
+        print("❌ CONFIG VALIDATION FAILED:")
+        for e in errors:
+            print(" -", e)
+        sys.exit(1)
+
+    print("✅ All configs are valid.")
+
+
+if __name__ == "__main__":
+    validate_all()

{serverwatcher-4.0.1 → serverwatcher-4.2}/src/serverwatcher/watcher.py

@@ -18,6 +18,14 @@ from serverwatcher.configclasses.global_config import GlobalConfig
 from serverwatcher.configclasses.messages import MessagesConfig
 from serverwatcher.configclasses.watcher import WatcherConfig
 
+# Validate and autorepair configs before watcher starts
+from serverwatcher.validator import validate_all
+from serverwatcher.autorepair import autorepair_all
+
+validate_all()
+autorepair_all()
+validate_all()
+
 class ServerWatcher:
     def __init__(self):
 
@@ -64,18 +72,18 @@ class ServerWatcher:
             tpsCommand=self.global_cfg.tps_command,
         )
 
-        logger_name = self.cfg.logger_name_template.format(
+        logger_name = self.global_cfg.logger_name.format(
             server_name=self.global_cfg.server_name
         )
 
         self.log = HungerLogger(
             name=logger_name,
             server=self.server,
-            log_path=self.cfg.log_path,
-            console_backspaces=self.cfg.console_backspaces,
+            log_path=self.global_cfg.log_path,
+            console_backspaces=self.global_cfg.console_backspaces,
         )
 
-        self.tz = ZoneInfo(self.cfg.timezone)
+        self.tz = ZoneInfo(self.global_cfg.timezone)
 
     # utility
     def fmt(self, template: str, **kwargs):
@@ -101,7 +109,7 @@ class ServerWatcher:
 
         if alive:
             self.log.info(self.messages.server_back_online)
-            self.server.sendBroadcast(self.messages.server_back_online_broadcast)
+            self.server.sendBroadcast(f"{self.messages.server_back_online_broadcast}")
             self.origin.enableSchedule(self.cfg.origin_disable_schedule_id)
         else:
             self.log.error(self.messages.server_failed_restart)
@@ -239,10 +247,10 @@ class ServerWatcher:
 
     # main loop
     def run(self):
-        if self.cfg.clear_terminal:
+        if self.global_cfg.clear_terminal:
             clearTerminal()
         while True:
-            if self.cfg.clear_terminal:
+            if self.global_cfg.clear_terminal:
                 clearTerminal()
             self.evaluate()
-            time.sleep(self.cfg.watch_interval)
+            time.sleep(self.global_cfg.watch_interval)

{serverwatcher-4.0.1 → serverwatcher-4.2/src/serverwatcher.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: serverwatcher
-Version: 4.0.1
+Version: 4.2
 Summary: A HungerLib-powered Minecraft server automation engine.
 Author: iFamished
 License: GPL-3.0

{serverwatcher-4.0.1 → serverwatcher-4.2}/src/serverwatcher.egg-info/SOURCES.txt

@@ -2,6 +2,8 @@ LICENSE
 README.md
 pyproject.toml
 src/serverwatcher/__init__.py
+src/serverwatcher/autorepair.py
+src/serverwatcher/validation.py
 src/serverwatcher/watcher.py
 src/serverwatcher.egg-info/PKG-INFO
 src/serverwatcher.egg-info/SOURCES.txt