izteamslots 1.1.0

package/backend/rpc_protocol.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class RPCRequest:
+    request_id: str
+    method: str
+    params: dict[str, Any]
+
+
+class RPCError(Exception):
+    def __init__(self, code: int, message: str, data: dict[str, Any] | None = None) -> None:
+        self.code = code
+        self.message = message
+        self.data = data or {}
+        super().__init__(message)
+
+    def to_dict(self) -> dict[str, Any]:
+        out = {
+            "code": self.code,
+            "message": self.message,
+        }
+        if self.data:
+            out["data"] = self.data
+        return out
+
+
+def parse_request(line: str) -> RPCRequest:
+    try:
+        payload = json.loads(line)
+    except json.JSONDecodeError as e:
+        raise RPCError(-32700, "Parse error", {"details": str(e)}) from e
+
+    if not isinstance(payload, dict):
+        raise RPCError(-32600, "Invalid request", {"details": "payload must be object"})
+
+    request_id = payload.get("id")
+    method = payload.get("method")
+    params = payload.get("params", {})
+
+    if not isinstance(request_id, str) or not request_id:
+        raise RPCError(-32600, "Invalid request", {"details": "id must be non-empty string"})
+    if not isinstance(method, str) or not method:
+        raise RPCError(-32600, "Invalid request", {"details": "method must be non-empty string"})
+    if not isinstance(params, dict):
+        raise RPCError(-32602, "Invalid params", {"details": "params must be object"})
+
+    return RPCRequest(request_id=request_id, method=method, params=params)
+
+
+def make_success_response(request_id: str, result: Any) -> dict[str, Any]:
+    return {
+        "type": "response",
+        "id": request_id,
+        "ok": True,
+        "result": result,
+    }
+
+
+def make_error_response(request_id: str, error: RPCError) -> dict[str, Any]:
+    return {
+        "type": "response",
+        "id": request_id,
+        "ok": False,
+        "error": error.to_dict(),
+    }
+
+
+def make_event(event: str, data: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "type": "event",
+        "event": event,
+        "data": data,
+    }

package/backend/rpc_server.py

@@ -0,0 +1,233 @@
+from __future__ import annotations
+
+import json
+import sys
+import threading
+import traceback
+from typing import Any
+
+from .file_logger import FileLogger
+from .jobs import JobManager
+from .rpc_protocol import (
+    RPCError,
+    RPCRequest,
+    make_error_response,
+    make_event,
+    make_success_response,
+    parse_request,
+)
+from .ui_facade import UIFacade
+
+
+class RPCServer:
+    def __init__(self) -> None:
+        self.logger = FileLogger()
+        self.facade = UIFacade()
+        self._out_lock = threading.Lock()
+        self.jobs = JobManager(self.emit_event, file_logger=self.logger)
+        self.logger.info("RPC server initialized")
+
+    def emit_event(self, event: str, data: dict[str, Any]) -> None:
+        self._write_json(make_event(event, data))
+
+    def _write_json(self, payload: dict[str, Any]) -> None:
+        line = json.dumps(payload, ensure_ascii=False)
+        with self._out_lock:
+            sys.stdout.write(line + "\n")
+            sys.stdout.flush()
+
+    def _as_str_param(self, params: dict[str, Any], key: str) -> str:
+        value = params.get(key)
+        if not isinstance(value, str) or not value:
+            raise RPCError(-32602, "Invalid params", {"details": f"'{key}' must be non-empty string"})
+        return value
+
+    def _as_int_param(self, params: dict[str, Any], key: str) -> int:
+        value = params.get(key)
+        if not isinstance(value, int):
+            raise RPCError(-32602, "Invalid params", {"details": f"'{key}' must be integer"})
+        return value
+
+    def _run_job(self, title: str, fn):
+        return self.jobs.start(title, fn)
+
+    def _handle_request(self, req: RPCRequest) -> dict[str, Any]:
+        m = req.method
+        p = req.params
+
+        if m == "ping":
+            return make_success_response(req.request_id, {"pong": True})
+
+        if m == "state.get":
+            return make_success_response(req.request_id, self.facade.get_state())
+
+        if m == "admins.list":
+            return make_success_response(req.request_id, {"items": self.facade.list_admins()})
+
+        if m == "workers.list":
+            return make_success_response(req.request_id, {"items": self.facade.list_workers()})
+
+        if m == "workers.by_admin":
+            email = self._as_str_param(p, "admin_email")
+            return make_success_response(req.request_id, {"items": self.facade.list_workers_by_admin(email)})
+
+        if m == "accounts.mail.list":
+            return make_success_response(req.request_id, {"items": self.facade.list_mail_accounts()})
+
+        if m == "admin.add":
+            email = self._as_str_param(p, "email")
+            password = self._as_str_param(p, "password")
+            item = self.facade.add_admin(email, password)
+            return make_success_response(req.request_id, {"item": item})
+
+        if m == "job.add_admin_manual":
+            job_id = self._run_job(
+                "Ручное добавление админа",
+                lambda ctx: self.facade.add_admin_manual(ctx.log),
+            )
+            return make_success_response(req.request_id, {"job_id": job_id})
+
+        if m == "admin.delete":
+            email = self._as_str_param(p, "email")
+            self.facade.delete_admin(email)
+            return make_success_response(req.request_id, {"deleted": True})
+
+        if m == "worker.delete":
+            email = self._as_str_param(p, "email")
+            self.facade.delete_worker(email)
+            return make_success_response(req.request_id, {"deleted": True})
+
+        if m == "job.login_admin":
+            email = self._as_str_param(p, "email")
+            job_id = self._run_job(
+                f"Логин админа: {email}",
+                lambda ctx: self.facade.login_admin(email, ctx.log),
+            )
+            return make_success_response(req.request_id, {"job_id": job_id})
+
+        if m == "job.login_admin_manual":
+            email = self._as_str_param(p, "email")
+            job_id = self._run_job(
+                f"Ручной логин админа: {email}",
+                lambda ctx: self.facade.login_admin_manual(email, ctx.log),
+            )
+            return make_success_response(req.request_id, {"job_id": job_id})
+
+        if m == "job.open_admin_browser":
+            email = self._as_str_param(p, "email")
+            job_id = self._run_job(
+                f"Браузер админа: {email}",
+                lambda ctx: self.facade.open_admin_browser(email, ctx.log),
+            )
+            return make_success_response(req.request_id, {"job_id": job_id})
+
+        if m == "job.run_slots":
+            admin_email = self._as_str_param(p, "admin_email")
+            count = self._as_int_param(p, "count")
+            if count <= 0:
+                raise RPCError(-32602, "Invalid params", {"details": "'count' must be > 0"})
+            job_id = self._run_job(
+                f"Пайплайн слотов ({admin_email})",
+                lambda ctx: self.facade.run_slots_pipeline(
+                    admin_email,
+                    count,
+                    ctx.log,
+                    progress=ctx.progress,
+                ),
+            )
+            return make_success_response(req.request_id, {"job_id": job_id})
+
+        if m == "job.relogin_worker":
+            email = self._as_str_param(p, "email")
+            job_id = self._run_job(
+                f"Перелогин: {email}",
+                lambda ctx: self.facade.relogin_worker_email(email, ctx.log),
+            )
+            return make_success_response(req.request_id, {"job_id": job_id})
+
+        if m == "job.relogin_all_workers":
+            job_id = self._run_job(
+                "Перелогин всех слотов",
+                lambda ctx: self.facade.relogin_all_workers(ctx.log, progress=ctx.progress),
+            )
+            return make_success_response(req.request_id, {"job_id": job_id})
+
+        if m == "job.open_worker_browser":
+            email = self._as_str_param(p, "email")
+            job_id = self._run_job(
+                f"Браузер слота: {email}",
+                lambda ctx: self.facade.open_worker_browser(email, ctx.log),
+            )
+            return make_success_response(req.request_id, {"job_id": job_id})
+
+        if m == "job.fetch_mail":
+            email = self._as_str_param(p, "email")
+            job_id = self._run_job(
+                f"Почта: {email}",
+                lambda ctx: self.facade.fetch_mail(email, ctx.log),
+            )
+            return make_success_response(req.request_id, {"job_id": job_id})
+
+        if m == "shutdown":
+            self.facade.shutdown()
+            return make_success_response(req.request_id, {"ok": True})
+
+        raise RPCError(-32601, "Method not found", {"method": m})
+
+    def serve(self) -> None:
+        for raw in sys.stdin:
+            line = raw.strip()
+            if not line:
+                continue
+
+            req: RPCRequest | None = None
+            try:
+                req = parse_request(line)
+                response = self._handle_request(req)
+            except RPCError as e:
+                self.logger.error(f"RPC error for request {req.request_id if req else 'unknown'}: {e}")
+                request_id = req.request_id if req else "unknown"
+                if request_id == "unknown":
+                    try:
+                        maybe = json.loads(line)
+                        if isinstance(maybe, dict) and isinstance(maybe.get("id"), str):
+                            request_id = maybe["id"]
+                    except Exception:
+                        pass
+                response = make_error_response(request_id, e)
+            except Exception as e:
+                tb = traceback.format_exc()
+                self.logger.error(f"Unhandled server error: {e}", traceback_text=tb)
+                request_id = req.request_id if req else "unknown"
+                response = make_error_response(
+                    request_id,
+                    RPCError(
+                        -32000,
+                        "Server error",
+                        {
+                            "details": str(e),
+                            "traceback": tb,
+                        },
+                    ),
+                )
+
+            self._write_json(response)
+
+        self.facade.shutdown()
+        self.logger.info("RPC server stopped")
+
+
+def main() -> int:
+    from pathlib import Path
+
+    from dotenv import load_dotenv
+
+    load_dotenv(Path(__file__).resolve().parent.parent / ".env")
+
+    server = RPCServer()
+    server.serve()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())