lockbot 2.4.0__tar.gz → 2.5.1__tar.gz

{lockbot-2.4.0/python/lockbot.egg-info → lockbot-2.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lockbot
-Version: 2.4.0
+Version: 2.5.1
 Summary: Cluster resource management bot for IM platforms
 Author-email: Jianbang Yang <yangjianbang112@gmail.com>
 License: MIT
@@ -36,7 +36,7 @@ Requires-Dist: httpx
 Requires-Dist: slowapi
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
-Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: ruff==0.15.10; extra == "dev"
 Dynamic: license-file
 
 # lockbot

{lockbot-2.4.0 → lockbot-2.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "lockbot"
-version = "2.4.0"
+version = "2.5.1"
 description = "Cluster resource management bot for IM platforms"
 readme = "README.md"
 license = {text = "MIT"}
@@ -47,7 +47,7 @@ dependencies = [
 [project.optional-dependencies]
 dev = [
     "pytest>=7.0",
-    "ruff>=0.1.0",
+    "ruff==0.15.10",
 ]
 
 [project.urls]

lockbot-2.5.1/python/lockbot/backend/app/bots/manager.py

@@ -0,0 +1,154 @@
+"""
+Bot instance manager (in-process, shared port).
+
+All bots run inside the FastAPI process as BotInstance objects.
+Webhook callbacks arrive at /api/bots/webhook/{bot_id} and are
+dispatched to the corresponding BotInstance.
+"""
+
+import logging
+import os
+import threading
+
+from lockbot.core.bot_instance import BotInstance
+from lockbot.core.scheduler import BotScheduler
+
+logger = logging.getLogger(__name__)
+
+
+class BotManager:
+    """
+    Manages bot instances running in the FastAPI process.
+
+    Usage:
+        manager = BotManager()
+        manager.start_scheduler()
+        manager.start_bot(bot_id=1, config_dict={...})
+        instance = manager.get_instance(bot_id=1)
+        manager.stop_bot(bot_id=1)
+        manager.shutdown_all()
+    """
+
+    def __init__(self):
+        self._bots: dict[int, BotInstance] = {}
+        self._lock = threading.Lock()
+        self._scheduler = BotScheduler()
+
+    def start_scheduler(self) -> None:
+        """Start the shared scheduler background thread. Call once at app startup."""
+        self._scheduler.start()
+
+    def is_running(self, bot_id: int) -> bool:
+        return bot_id in self._bots
+
+    def get_pid(self, bot_id: int) -> int | None:
+        if bot_id in self._bots:
+            return os.getpid()
+        return None
+
+    def get_instance(self, bot_id: int) -> BotInstance | None:
+        """Get the BotInstance for webhook dispatching."""
+        return self._bots.get(bot_id)
+
+    def start_bot(self, bot_id: int, config_dict: dict) -> int:
+        """
+        Start a bot instance in-process.
+
+        Returns:
+            PID of the current process.
+
+        Raises:
+            RuntimeError: If the bot is already running.
+        """
+        with self._lock:
+            if bot_id in self._bots:
+                raise RuntimeError(f"Bot {bot_id} is already running")
+
+            instance = BotInstance(
+                config_dict.get("BOT_TYPE", "NODE"),
+                config_dict,
+                scheduler=self._scheduler,  # managed mode: shared scheduler
+            )
+            self._bots[bot_id] = instance
+
+        # Schedule first check immediately (outside _lock to avoid lock ordering issues)
+        self._scheduler.add(
+            bot_id,
+            instance,
+            delay=0.0,
+            on_fatal_error=self._make_fatal_error_handler(bot_id),
+        )
+        # Wire up state-change callback so new locks wake the scheduler immediately
+        instance.bot._on_state_changed = lambda: self._scheduler.reschedule_soon(bot_id)
+        logger.info("Started bot %d in-process (type=%s)", bot_id, instance.bot_type)
+        return os.getpid()
+
+    def _make_fatal_error_handler(self, bot_id: int):
+        """Return a closure that marks the bot as 'error' in DB after too many failures."""
+
+        def _on_fatal_error(failed_bot_id: int) -> None:
+            # Remove from active bots (scheduler already removed itself)
+            with self._lock:
+                self._bots.pop(failed_bot_id, None)
+
+            # Update DB status — runs in scheduler thread, create own session
+            try:
+                from lockbot.backend.app.bots.models import Bot as BotModel
+                from lockbot.backend.app.database import SessionLocal
+
+                db = SessionLocal()
+                try:
+                    bot = db.query(BotModel).filter(BotModel.id == failed_bot_id).first()
+                    if bot:
+                        bot.status = "error"
+                        bot.pid = None
+                        db.commit()
+                        logger.critical(
+                            "Bot %d (%s): marked as error in DB after repeated failures",
+                            failed_bot_id,
+                            bot.name,
+                        )
+                finally:
+                    db.close()
+            except Exception:
+                logger.exception("Bot %d: failed to update DB status to error", failed_bot_id)
+
+        return _on_fatal_error
+
+    def stop_bot(self, bot_id: int) -> None:
+        """
+        Stop a bot instance.
+
+        Raises:
+            RuntimeError: If the bot is not running.
+        """
+        # Cancel scheduling before removing from _bots
+        self._scheduler.remove(bot_id)
+        with self._lock:
+            if bot_id not in self._bots:
+                raise RuntimeError(f"Bot {bot_id} is not running")
+            self._bots.pop(bot_id)
+        logger.info("Stopped bot %d", bot_id)
+
+    def restart_bot(self, bot_id: int, config_dict: dict) -> int:
+        """Stop then start a bot. Returns PID."""
+        if self.is_running(bot_id):
+            self.stop_bot(bot_id)
+        return self.start_bot(bot_id, config_dict)
+
+    def shutdown_all(self) -> None:
+        """Stop the scheduler and clear all running bots. Called on platform shutdown."""
+        self._scheduler.stop()
+        with self._lock:
+            self._bots.clear()
+        # Clear scheduler state so it can be safely restarted (e.g. in tests)
+        with self._scheduler._lock:
+            self._scheduler._instances.clear()
+            self._scheduler._heap.clear()
+            self._scheduler._gens.clear()
+            self._scheduler._failure_counts.clear()
+            self._scheduler._callbacks.clear()
+
+
+# Module-level singleton
+bot_manager = BotManager()

{lockbot-2.4.0 → lockbot-2.5.1}/python/lockbot/backend/app/bots/router.py

@@ -1123,7 +1123,10 @@ async def _reply_bot_not_running(
     owner_username = owner.username if owner else ""
 
     # Build and send "bot not running" reply
-    content = t("webhook.bot_not_running", lang=lang, bot_name=bot.name, owner_username=owner_username)
+    if bot.status == "error":
+        content = t("webhook.bot_error", lang=lang, bot_name=bot.name, owner_username=owner_username)
+    else:
+        content = t("webhook.bot_not_running", lang=lang, bot_name=bot.name, owner_username=owner_username)
     reply = adapter.build_reply(content, [user_id], group_id=group_id)
     toid = msg_data["message"]["header"].get("toid")
     if toid:

{lockbot-2.4.0 → lockbot-2.5.1}/python/lockbot/backend/app/bots/schemas.py

@@ -4,7 +4,38 @@ Bot Pydantic schemas
 
 from datetime import datetime
 
-from pydantic import BaseModel
+from pydantic import BaseModel, field_validator
+
+# ── config_overrides value bounds ─────────────────────────────────────────────
+_CFG_RULES: dict[str, tuple[int, int] | None] = {
+    # (min, max); None means special-cased below
+    "DEFAULT_DURATION": (60, 604800),  # 1 min – 7 days
+    "TIME_ALERT": (30, 3600),  # 30 s – 1 h
+    "MAX_LOCK_DURATION": None,  # -1 (unlimited) or 300–604800
+}
+
+
+def _validate_config_overrides(v: dict | None) -> dict | None:
+    if not v:
+        return v
+    errors: list[str] = []
+    for key, bounds in _CFG_RULES.items():
+        if key not in v:
+            continue
+        val = v[key]
+        if not isinstance(val, int):
+            errors.append(f"{key} must be an integer")
+            continue
+        if key == "MAX_LOCK_DURATION":
+            if val != -1 and not (300 <= val <= 604800):
+                errors.append("MAX_LOCK_DURATION must be -1 (unlimited) or between 300 and 604800")
+        else:
+            lo, hi = bounds  # type: ignore[misc]
+            if not (lo <= val <= hi):
+                errors.append(f"{key} must be between {lo} and {hi}")
+    if errors:
+        raise ValueError("; ".join(errors))
+    return v
 
 
 class BotCreate(BaseModel):
@@ -18,6 +49,11 @@ class BotCreate(BaseModel):
     cluster_configs: dict | list
     config_overrides: dict | None = None
 
+    @field_validator("config_overrides")
+    @classmethod
+    def validate_config_overrides(cls, v: dict | None) -> dict | None:
+        return _validate_config_overrides(v)
+
 
 class BotUpdate(BaseModel):
     name: str | None = None
@@ -28,6 +64,11 @@ class BotUpdate(BaseModel):
     cluster_configs: dict | list | None = None
     config_overrides: dict | None = None
 
+    @field_validator("config_overrides")
+    @classmethod
+    def validate_config_overrides(cls, v: dict | None) -> dict | None:
+        return _validate_config_overrides(v)
+
 
 class BotOut(BaseModel):
     id: int

{lockbot-2.4.0 → lockbot-2.5.1}/python/lockbot/backend/app/config.py

@@ -19,7 +19,7 @@ DATABASE_URL = os.environ.get(
 # JWT
 JWT_SECRET = os.environ.get("JWT_SECRET", "lockbot-dev-secret-change-me")
 JWT_ALGORITHM = "HS256"
-JWT_EXPIRE_MINUTES = 60 * 24 * 7  # 7 days
+JWT_EXPIRE_MINUTES = 60 * 24 * 90  # 90 days (~3 months)
 
 # Fernet encryption key (for sensitive fields)
 ENCRYPTION_KEY = os.environ.get("ENCRYPTION_KEY", "")

{lockbot-2.4.0 → lockbot-2.5.1}/python/lockbot/backend/app/main.py

@@ -204,11 +204,12 @@ async def lifespan(app: FastAPI):
     _migrate_audit_logs()
     _seed_dev_admin()
     _seed_dev_users()
-    _reset_running_bots()
-    yield
-    # Shutdown: cancel all bot timers and clean up
     from lockbot.backend.app.bots.manager import bot_manager
 
+    bot_manager.start_scheduler()
+    _reset_running_bots()
+    yield
+    # Shutdown: stop scheduler and clean up all bots
     logger.info("Shutting down all bots…")
     bot_manager.shutdown_all()
 

{lockbot-2.4.0 → lockbot-2.5.1}/python/lockbot/core/base_bot.py

@@ -4,6 +4,7 @@ lockbot - BaseLockBot
 
 import logging
 import threading
+from collections.abc import Callable
 from importlib.metadata import version as _pkg_version
 
 from lockbot.core.config import Config
@@ -42,9 +43,6 @@ class BaseLockBot:
     # Subclasses MUST define an inner _state_class(BotState) with a _loader.
     _state_class = None
 
-    _timer_failure_count = 0
-    _MAX_TIMER_FAILURES = 5
-
     logger = logging.getLogger("lockbot.timer")
 
     # ------------------------------------------------------------------ init
@@ -68,6 +66,27 @@ class BaseLockBot:
 
         self._lock = lock or threading.Lock()
         self.adapter = adapter or InfoflowAdapter(config=self.config)
+        # Optional callback: invoked after a successful lock/slock so the
+        # scheduler can recalculate its next wakeup without waiting for idle.
+        self._on_state_changed: Callable[[], None] | None = None
+
+    def _notify_state_changed(self) -> None:
+        """Call _on_state_changed if wired up (no-op otherwise)."""
+        if self._on_state_changed is not None:
+            self._on_state_changed()
+
+    def _save_and_notify(self) -> None:
+        """Persist bot state to disk and wake the scheduler (if wired).
+
+        Use this in every command handler that mutates state so it's
+        impossible to forget either step.  The scheduler's
+        ``_check_and_notify`` loop should still call ``save_bot_state_to_file``
+        directly to avoid an unwanted reschedule from the timer thread.
+        """
+        from lockbot.core.io import save_bot_state_to_file
+
+        save_bot_state_to_file(self.state.bot_state, config=self.config)
+        self._notify_state_changed()
 
     # ---------------------------------------------------------- show_error
     def show_error(self, user_id, error_msg):
@@ -76,34 +95,6 @@ class BaseLockBot:
         """
         return self.adapter.build_reply("\u274c" + error_msg, [user_id])
 
-    # -------------------------------------------------------- timer_routine
-    def timer_routine(self):
-        """
-        Timer routine entrypoint: run _check_and_notify every 5 seconds.
-
-        Self-healing: if _check_and_notify raises, log the error and
-        continue scheduling the next tick.  After _MAX_TIMER_FAILURES
-        consecutive failures, back off to 30-second intervals.
-        """
-        try:
-            self._check_and_notify()
-            self._timer_failure_count = 0
-        except Exception:
-            self._timer_failure_count += 1
-            bot_name = self.config.get_val("BOT_NAME") if self.config else "?"
-            self.logger.exception(
-                "timer_routine crashed for bot %s (failure %d/%d)",
-                bot_name,
-                self._timer_failure_count,
-                self._MAX_TIMER_FAILURES,
-            )
-
-        # Back off when too many consecutive failures
-        interval = 30.0 if self._timer_failure_count >= self._MAX_TIMER_FAILURES else 5.0
-        self._timer = threading.Timer(interval, self.timer_routine)
-        self._timer.daemon = True
-        self._timer.start()
-
     # ------------------------------------------------------ _msg_with_usage
     def _msg_with_usage(self, msg_key, *, node_key=None, sep="", **kwargs):
         """Return ``t(msg_key, ...) + sep + self._current_usage(node_key)``."""

lockbot-2.5.1/python/lockbot/core/bot_instance.py

@@ -0,0 +1,79 @@
+"""
+bot_instance.py - Bot instance factory.
+
+Creates the appropriate Bot instance based on bot_type.
+Each instance holds independent Config, State and Lock,
+supporting multiple concurrent bots in a single process.
+"""
+
+from lockbot.core.device_bot import DeviceBot
+from lockbot.core.node_bot import NodeBot
+from lockbot.core.queue_bot import QueueBot
+
+_BOT_CLASS_MAP = {
+    "NODE": NodeBot,
+    "QUEUE": QueueBot,
+    "DEVICE": DeviceBot,
+}
+
+_STANDALONE_KEY = 0  # internal scheduler key used in standalone mode
+
+
+class BotInstance:
+    """
+    Wraps an independent Bot instance.
+
+    Usage:
+        instance = BotInstance("NODE", {"BOT_NAME": "my_bot", ...})
+        instance.bot        # NodeBot / QueueBot / DeviceBot instance
+        instance.bot.config # Config instance
+        instance.bot.state  # State instance
+
+    Scheduling:
+        Standalone mode (scheduler=None, default):
+            A private BotScheduler is created and started automatically.
+            Call instance.shutdown() to stop it when done.
+
+        Managed mode (scheduler provided by BotManager):
+            No scheduler is created here.  BotManager calls
+            scheduler.add(bot_id, instance) after construction and
+            scheduler.remove(bot_id) on teardown.
+    """
+
+    def __init__(self, bot_type, config_dict=None, scheduler=None, auto_start=True):
+        if bot_type not in _BOT_CLASS_MAP:
+            raise ValueError(f"Invalid bot_type '{bot_type}', must be one of {list(_BOT_CLASS_MAP.keys())}")
+
+        full_config = dict(config_dict or {})
+        full_config["BOT_TYPE"] = bot_type
+
+        self.bot_type = bot_type
+        bot_cls = _BOT_CLASS_MAP[bot_type]
+        self.bot = bot_cls(config_dict=full_config)
+
+        self.config = self.bot.config
+        self.state = self.bot.state
+
+        if not auto_start:
+            # Testing/manual mode: no scheduler
+            self._scheduler = None
+            self._owns_scheduler = False
+        elif scheduler is None:
+            # Standalone mode: own scheduler, start immediately
+            from lockbot.core.scheduler import BotScheduler
+
+            self._scheduler = BotScheduler()
+            self._scheduler.start()
+            self._owns_scheduler = True
+            self._scheduler.add(_STANDALONE_KEY, self, delay=0.0)
+            self.bot._on_state_changed = lambda: self._scheduler.reschedule_soon(_STANDALONE_KEY)
+        else:
+            # Managed mode: shared scheduler injected by BotManager
+            self._scheduler = scheduler
+            self._owns_scheduler = False
+
+    def shutdown(self) -> None:
+        """Stop scheduling (standalone mode only). No-op in managed mode."""
+        if self._owns_scheduler:
+            self._scheduler.remove(_STANDALONE_KEY)
+            self._scheduler.stop()

{lockbot-2.4.0 → lockbot-2.5.1}/python/lockbot/core/device_bot.py

@@ -225,9 +225,8 @@ class DeviceBot(BaseLockBot):
                 self._msg_with_usage("success.resource_locked", node_key=node_key_list), [user_id]
             )
 
-            save_bot_state_to_file(self.state.bot_state, config=self.config)
             log_to_file(user_id, "lock", node_key, dev_ids, duration, config=self.config)
-
+            self._save_and_notify()
             return reply
 
     def slock(self, user_id, command):
@@ -291,8 +290,8 @@ class DeviceBot(BaseLockBot):
                 self._msg_with_usage("success.resource_locked", node_key=node_key_list), [user_id]
             )
 
-            save_bot_state_to_file(self.state.bot_state, config=self.config)
             log_to_file(user_id, "slock", node_key_list, dev_ids_list, duration, config=self.config)
+            self._save_and_notify()
             return reply
 
     def unlock(self, user_id, command):
@@ -311,8 +310,8 @@ class DeviceBot(BaseLockBot):
                             if len(device["current_users"]) == 0:
                                 device["status"] = "idle"
                 reply = self.adapter.build_reply(self._msg_with_usage("success.resource_released"), [user_id])
-                save_bot_state_to_file(self.state.bot_state, config=self.config)
                 log_to_file(user_id, "unlock", "all", "all", config=self.config)
+                self._save_and_notify()
                 return reply
 
         m = re.match(r"^\s*(unlock|free)\s+([\w\d]+)(\s*[,，、]\s*([\w\d])+)*\s*$", command)
@@ -343,8 +342,8 @@ class DeviceBot(BaseLockBot):
                             if len(device["current_users"]) == 0:
                                 device["status"] = "idle"
                 reply = self.adapter.build_reply(self._msg_with_usage("success.resource_released"), [user_id])
-                save_bot_state_to_file(self.state.bot_state, config=self.config)
                 log_to_file(user_id, "unlock", node_key, "all", config=self.config)
+                self._save_and_notify()
                 return reply
 
         # Case 3: Release specific devices requested by the user
@@ -372,8 +371,8 @@ class DeviceBot(BaseLockBot):
             reply = self.adapter.build_reply(
                 self._msg_with_usage("success.resource_released", node_key=node_key_list), [user_id]
             )
-            save_bot_state_to_file(self.state.bot_state, config=self.config)
             log_to_file(user_id, "unlock", node_key_list, dev_ids_list, config=self.config)
+            self._save_and_notify()
             return reply
 
     def kickout(self, user_id, command):
@@ -402,9 +401,8 @@ class DeviceBot(BaseLockBot):
             content += self._msg_with_usage("label.after_release", node_key=node_key_list)
             reply = self.adapter.build_reply(content, list(users))
 
-            save_bot_state_to_file(self.state.bot_state, config=self.config)
             log_to_file(user_id, "kickout", node_key_list, dev_ids_list, config=self.config)
-
+            self._save_and_notify()
             return reply
 
     def _help_commands(self):
@@ -438,13 +436,13 @@ class DeviceBot(BaseLockBot):
 
         return text
 
-    def _check_and_notify(self):
+    def _check_and_notify(self) -> float | None:
         """
         Check and notify when resource availability time is running low or resources have been released.
         If EARLY_NOTIFY is set, sends an early notification when remaining time is less than TIME_ALERT.
         Otherwise, notifies after resources are automatically released.
 
-        Returns: None. Modifies bot_state and user_ids as side effects.
+        Returns: seconds until next interesting event, or None if no active locks.
         """
         EARLY_NOTIFY = self.config.get_val("EARLY_NOTIFY")
         TIME_ALERT = self.config.get_val("TIME_ALERT")
@@ -466,7 +464,12 @@ class DeviceBot(BaseLockBot):
                             if remaining_time <= 0:
                                 removed_users_id.append(user_info["user_id"])
                                 state_changed = True
-                                if not EARLY_NOTIFY:
+
+                                # Send expiry notification only if early warning was never sent.
+                                # When EARLY_NOTIFY=True and warning fired on time, is_notified=True → silent release.
+                                # When EARLY_NOTIFY=False, is_notified is always False → always notify here.
+                                # Fallback: EARLY_NOTIFY=True but scheduler delayed past expiry → notify here instead.
+                                if not user_info.get("is_notified"):
                                     trigger_time_alert = True
                                     user_ids.add(user_info["user_id"])
                                     alert_tuples.append(
@@ -478,7 +481,7 @@ class DeviceBot(BaseLockBot):
                                             remaining_time,
                                         )
                                     )
-                            if EARLY_NOTIFY and not user_info.get("is_notified") and remaining_time <= TIME_ALERT:
+                            if EARLY_NOTIFY and not user_info.get("is_notified") and 0 < remaining_time <= TIME_ALERT:
                                 trigger_time_alert = True
                                 user_ids.add(user_info["user_id"])
                                 user_info["is_notified"] = True
@@ -503,13 +506,33 @@ class DeviceBot(BaseLockBot):
             if state_changed:
                 save_bot_state_to_file(self.state.bot_state, config=self.config)
 
+            # Compute next wakeup: scan remaining active users after mutations
+            min_next = float("inf")
+            for devices in self.state.bot_state.values():
+                for device in devices:
+                    if device["status"] != "idle":
+                        for user_info in device["current_users"]:
+                            remaining = remaining_duration(user_info["start_time"], user_info["duration"])
+                            if remaining <= 0:
+                                continue
+                            if EARLY_NOTIFY and not user_info.get("is_notified"):
+                                next_event = remaining - TIME_ALERT
+                            else:
+                                next_event = remaining
+                            min_next = min(min_next, next_event)
+
         grouped_devices = group_devices_by_node_user_and_mode(alert_tuples)
         for node_key, user_id, (dev_start, dev_end), status, remaining_time in grouped_devices:
             alert_info += format_alert_info(node_key, user_id, dev_start, dev_end, status, remaining_time)
 
         if trigger_time_alert:
             msg = self.adapter.build_reply(alert_info + "\n", list(user_ids))
-            self.adapter.send(msg)
+            try:
+                self.adapter.send(msg)
+            except Exception:
+                self.logger.exception("Failed to send alert for bot %s", self.config.get_val("BOT_NAME"))
+
+        return max(1.0, min_next) if min_next != float("inf") else None
 
     def _current_usage(self, node_filter=None):
         """

{lockbot-2.4.0 → lockbot-2.5.1}/python/lockbot/core/i18n/en.py

@@ -161,4 +161,6 @@ MESSAGES = {
     # ── Webhook: bot not running ──
     "webhook.bot_not_running": "⚠️ Bot {bot_name} is not running. "  # noqa: E501
     "Please contact the owner @{owner_username} to start it.",
+    "webhook.bot_error": "❌ Bot {bot_name} encountered an error. "  # noqa: E501
+    "Please contact the owner @{owner_username} for assistance.",
 }

{lockbot-2.4.0 → lockbot-2.5.1}/python/lockbot/core/i18n/zh.py

@@ -154,4 +154,5 @@ MESSAGES = {
     "state.dev_id_corrected": "节点 '{name}', 设备 {index}: dev_id 从 {old} 修正为 {new}",
     # ── Webhook: bot not running ──
     "webhook.bot_not_running": "⚠️ 机器人 {bot_name} 尚未启动，请联系管理人 @{owner_username} 启动后再使用。",
+    "webhook.bot_error": "❌ 机器人 {bot_name} 运行异常，请联系管理人 @{owner_username} 处理。",
 }