@agentunion/kite 1.4.0 → 1.6.0

package/extensions/services/redis/entry.py.backup

@@ -0,0 +1,405 @@
+#!/usr/bin/env python3
+"""Redis 模块入口 — 双层实现（外部 Redis + 内置简版）"""
+import os
+import sys
+import json
+import time
+import asyncio
+import uuid
+import websockets
+
+MODULE_NAME = "redis"
+
+# 全局状态
+_ws_global = None
+_start_ts = time.monotonic()
+_has_registered = False
+_shutting_down = False
+_exit_code = 0
+_redis_impl = None  # Redis 实现实例（外部或内置）
+_redis_ready = False
+_pending_rpc = {}  # rpc_id → Future
+
+
+async def _rpc_call(ws, method: str, params: dict = None, wait_response: bool = True, timeout: float = 3.0) -> dict:
+    """JSON-RPC 2.0 request"""
+    rpc_id = str(uuid.uuid4())
+    msg = {"jsonrpc": "2.0", "id": rpc_id, "method": method}
+    if params:
+        msg["params"] = params
+
+    if not wait_response:
+        await ws.send(json.dumps(msg))
+        return {}
+
+    future = asyncio.get_event_loop().create_future()
+    _pending_rpc[rpc_id] = future
+    await ws.send(json.dumps(msg))
+    try:
+        return await asyncio.wait_for(future, timeout=timeout)
+    except asyncio.TimeoutError:
+        _pending_rpc.pop(rpc_id, None)
+        return {"error": {"code": -32000, "message": f"RPC timeout: {method} ({timeout}s)"}}
+
+
+def _handle_rpc_response(msg: dict):
+    """Route JSON-RPC response to pending future"""
+    rpc_id = msg.get("id")
+    future = _pending_rpc.pop(rpc_id, None)
+    if future and not future.done():
+        future.set_result(msg)
+
+
+async def _publish_event(ws, event: str, data: dict = None):
+    """Publish event via event.publish RPC (fire-and-forget)"""
+    await _rpc_call(ws, "event.publish", {
+        "event_id": str(uuid.uuid4()),
+        "event": event,
+        "data": data or {},
+    }, wait_response=False)
+
+
+async def _do_init(ws):
+    """收到 system.require_init 后执行：subscribe + register + module.ready"""
+    global _has_registered
+    reason = "startup" if not _has_registered else "recovery"
+    print(f"[redis] Received system.require_init (reason={reason})")
+
+    # 1. Subscribe
+    await _rpc_call(ws, "event.subscribe", {
+        "events": ["system.ping", "module.ready", "module.shutdown"],
+    })
+    print(f"[redis] Subscribed to events")
+
+    # 2. Register
+    await _rpc_call(ws, "registry.register", {
+        "module_id": "redis",
+        "module_type": "service",
+        "max_connections": 1,
+        "connection_elastic": False,
+        "launcher_id": "launcher",
+        "tools": {
+            "rpc": {
+                "redis": {
+                    "ping": {"method": "ping", "description": "Ping Redis"},
+                    "get": {"method": "get", "description": "GET key"},
+                    "set": {"method": "set", "description": "SET key value"},
+                    "hget": {"method": "hget", "description": "HGET key field"},
+                    "hset": {"method": "hset", "description": "HSET key field value"},
+                    "info": {"method": "info", "description": "Redis 连接信息"},
+                }
+            }
+        },
+        "events_publish": ["system.redis_ready"],
+        "events_subscribe": ["system.ping", "module.shutdown"],
+    })
+    print(f"[redis] Registered to Kernel")
+
+    # 3. module.ready
+    if not _shutting_down:
+        await _publish_event(ws, "module.ready", {
+            "module_id": "redis",
+            "graceful_shutdown": True,
+            "startup_time": time.monotonic() - _start_ts,
+            "connection_elastic": False,
+            "reason": reason,
+        })
+        print(f"[redis] module.ready published (reason={reason})")
+
+    _has_registered = True
+
+
+async def _ws_receiver(ws):
+    """WebSocket 接收循环 — 三路分发"""
+    async for raw in ws:
+        try:
+            msg = json.loads(raw)
+        except (json.JSONDecodeError, TypeError):
+            continue
+
+        try:
+            has_method = "method" in msg
+            has_id = "id" in msg
+
+            if has_method and not has_id:
+                # 事件通知
+                params = msg.get("params", {})
+                event_type = params.get("event", "")
+
+                if event_type == "system.require_init":
+                    asyncio.create_task(_do_init(ws))
+                    continue
+
+                if event_type == "system.ping":
+                    asyncio.create_task(_handle_ping(ws, params.get("data", {})))
+                    continue
+
+                if event_type == "module.shutdown":
+                    asyncio.create_task(_handle_shutdown())
+                    continue
+
+            elif has_method and has_id:
+                # RPC 请求
+                asyncio.create_task(_handle_rpc_request(ws, msg))
+            elif not has_method and has_id:
+                # RPC 响应
+                _handle_rpc_response(msg)
+        except Exception as e:
+            print(f"[redis] 消息处理异常: {e}")
+
+
+async def _handle_ping(ws, data: dict):
+    """处理 system.ping 事件"""
+    t1 = data.get("ping_time")
+    t2 = time.time()
+    await _publish_event(ws, "system.pong", {
+        "module_id": MODULE_NAME,
+        "ping_time": t1,
+        "pong_time": t2,
+    })
+
+
+async def _handle_shutdown():
+    """处理优雅退出"""
+    global _shutting_down, _redis_impl, _ws_global
+    _shutting_down = True
+    print(f"[redis] Shutting down gracefully...")
+
+    if _redis_impl:
+        await _redis_impl.close()
+
+    if _ws_global:
+        await _ws_global.close()
+    sys.exit(0)
+
+
+async def _handle_rpc_request(ws, msg: dict):
+    """处理 RPC 请求"""
+    rpc_id = msg.get("id", "")
+    method = msg.get("method", "")
+    params = msg.get("params", {})
+
+    handlers = {
+        "ping": _rpc_ping,
+        "get": _rpc_get,
+        "set": _rpc_set,
+        "hget": _rpc_hget,
+        "hset": _rpc_hset,
+        "info": _rpc_info,
+    }
+
+    handler = handlers.get(method)
+    if handler:
+        try:
+            result = await handler(params)
+            await ws.send(json.dumps({"jsonrpc": "2.0", "id": rpc_id, "result": result}))
+        except Exception as e:
+            await ws.send(json.dumps({
+                "jsonrpc": "2.0", "id": rpc_id,
+                "error": {"code": -32603, "message": str(e)},
+            }))
+    else:
+        await ws.send(json.dumps({
+            "jsonrpc": "2.0", "id": rpc_id,
+            "error": {"code": -32601, "message": f"Method not found: {method}"},
+        }))
+
+
+async def _rpc_ping(params: dict) -> dict:
+    """RPC: redis.ping"""
+    if not _redis_ready:
+        raise Exception("Redis not ready")
+    return {"status": "ok", "message": "PONG"}
+
+
+async def _rpc_get(params: dict) -> dict:
+    """RPC: redis.get"""
+    if not _redis_ready or not _redis_impl:
+        raise Exception("Redis not ready")
+    key = params.get("key")
+    if not key:
+        raise Exception("Missing key parameter")
+    value = await _redis_impl.get(key)
+    return {"key": key, "value": value}
+
+
+async def _rpc_set(params: dict) -> dict:
+    """RPC: redis.set"""
+    if not _redis_ready or not _redis_impl:
+        raise Exception("Redis not ready")
+    key = params.get("key")
+    value = params.get("value")
+    if not key:
+        raise Exception("Missing key parameter")
+    await _redis_impl.set(key, value)
+    return {"status": "ok"}
+
+
+async def _rpc_hget(params: dict) -> dict:
+    """RPC: redis.hget"""
+    if not _redis_ready or not _redis_impl:
+        raise Exception("Redis not ready")
+    key = params.get("key")
+    field = params.get("field")
+    if not key or not field:
+        raise Exception("Missing key or field parameter")
+    value = await _redis_impl.hget(key, field)
+    return {"key": key, "field": field, "value": value}
+
+
+async def _rpc_hset(params: dict) -> dict:
+    """RPC: redis.hset"""
+    if not _redis_ready or not _redis_impl:
+        raise Exception("Redis not ready")
+    key = params.get("key")
+    field = params.get("field")
+    value = params.get("value")
+    if not key or not field:
+        raise Exception("Missing key or field parameter")
+    await _redis_impl.hset(key, field, value)
+    return {"status": "ok"}
+
+
+async def _rpc_info(params: dict) -> dict:
+    """RPC: redis.info"""
+    if not _redis_ready or not _redis_impl:
+        raise Exception("Redis not ready")
+    return {
+        "host": _redis_impl.host,
+        "port": _redis_impl.port,
+        "protocol": "RESP",
+        "type": "external" if hasattr(_redis_impl, "_client") else "builtin",
+    }
+
+
+async def main():
+    """主函数"""
+    global _ws_global, _redis_impl, _redis_ready
+
+    # 1. 从 stdin 读取 boot_info
+    line = sys.stdin.readline().strip()
+    if not line:
+        print(f"[redis] ERROR: stdin closed")
+        sys.exit(1)
+
+    try:
+        boot_info = json.loads(line)
+    except json.JSONDecodeError as e:
+        print(f"[redis] ERROR: Invalid JSON: {e}")
+        sys.exit(1)
+
+    if "error" in boot_info:
+        print(f"[redis] 启动失败: {boot_info.get('message')}")
+        sys.exit(1)
+
+    token = boot_info.get("token", "")
+    kernel_port = boot_info.get("kernel_port")
+
+    if not token:
+        print(f"[redis] ERROR: No token")
+        sys.exit(1)
+    if not kernel_port:
+        kernel_port = int(os.environ.get("KITE_KERNEL_PORT", 0))
+    if not kernel_port:
+        print(f"[redis] ERROR: No kernel_port")
+        sys.exit(1)
+
+    print(f"[redis] Received boot_info: kernel_port={kernel_port}")
+
+    # 2. 初始化 Redis 实现（双层）
+    redis_url = os.getenv("KITE_REDIS_URL")
+    if redis_url:
+        print(f"[redis] Using external Redis: {redis_url}")
+        from redis_external import ExternalRedis
+        _redis_impl = ExternalRedis(redis_url)
+    else:
+        print(f"[redis] Using built-in Redis implementation")
+        from redis_builtin import BuiltinRedis
+        _redis_impl = BuiltinRedis()
+
+    # 3. 启动 Redis 实现
+    try:
+        await _redis_impl.start()
+        _redis_ready = True
+        print(f"[redis] Redis implementation ready at {_redis_impl.host}:{_redis_impl.port}")
+    except Exception as e:
+        print(f"[redis] Failed to start Redis implementation: {e}")
+        sys.exit(1)
+
+    # 4. 连接 Kernel（带重连）
+    await _ws_loop(token, kernel_port)
+
+
+async def _ws_loop(token: str, kernel_port: int):
+    """连接 Kernel，带指数退避重连"""
+    global _shutting_down, _exit_code
+    retry_delay = 0.5
+    max_delay = 10.0
+
+    while not _shutting_down:
+        try:
+            await _ws_connect(token, kernel_port)
+            retry_delay = 0.5
+        except asyncio.CancelledError:
+            return
+        except Exception as e:
+            if _shutting_down:
+                return
+            print(f"[redis] 连接错误: {e}, {retry_delay:.1f}s 后重试")
+            await asyncio.sleep(retry_delay)
+            retry_delay = min(retry_delay * 2, max_delay)
+
+
+async def _ws_connect(token: str, kernel_port: int):
+    """单次 WebSocket 连接"""
+    global _ws_global
+
+    ws_url = f"ws://127.0.0.1:{kernel_port}/ws?id=redis"
+    print(f"[redis] Connecting to {ws_url}")
+
+    async with websockets.connect(ws_url, open_timeout=5, ping_interval=None, close_timeout=10) as ws:
+        # 认证
+        auth_req = {
+            "jsonrpc": "2.0",
+            "id": "auth",
+            "method": "auth",
+            "params": {"token": token}
+        }
+        await ws.send(json.dumps(auth_req))
+
+        # 等待认证响应
+        auth_resp_raw = await asyncio.wait_for(ws.recv(), timeout=5)
+        auth_resp = json.loads(auth_resp_raw)
+        if "error" in auth_resp:
+            raise Exception(f"Auth failed: {auth_resp['error']}")
+
+        _ws_global = ws
+        print(f"[redis] Connected to Kernel")
+
+        # 发布 system.redis_ready 事件（认证后立即发布）
+        if _redis_ready and _redis_impl:
+            await _publish_event(ws, "system.redis_ready", {
+                "host": _redis_impl.host,
+                "port": _redis_impl.port,
+                "protocol": "RESP",
+            })
+            print(f"[redis] Published system.redis_ready")
+
+        # 启动接收循环
+        receiver_task = asyncio.create_task(_ws_receiver(ws))
+        try:
+            await receiver_task
+        finally:
+            receiver_task.cancel()
+            for fut in _pending_rpc.values():
+                if not fut.done():
+                    fut.set_result({"error": {"code": -32001, "message": "Connection lost"}})
+            _pending_rpc.clear()
+
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        pass
+    sys.exit(_exit_code)

package/extensions/services/redis/module.md

@@ -0,0 +1,48 @@
+---
+name: redis
+display_name: Redis
+display_order: 79
+version: '1.0'
+type: service
+state: enabled
+max_connections: 1
+runtime: python
+entry: entry.py
+events:
+- system.redis_ready
+subscriptions:
+- system.ping
+- module.started
+- module.stopped
+- module.shutdown
+monitor: true
+businesses:
+- name: redis_service
+  type: redis
+  description: Redis 服务配置
+  config_file: config.json5
+---
+
+# Redis 模块
+
+为多实例模块提供共享状态基础设施。
+
+## 双层实现
+
+1. **外部 Redis**：配置 `KITE_REDIS_URL` 时直连外部 Redis/Valkey
+2. **内置简版**：未配置时使用内置 RESP 协议兼容实现
+
+## 环境变量
+
+- `KITE_REDIS_URL`：外部 Redis 连接 URL（可选，格式：`redis://host:port` 或 `redis://host:port/db`）
+- `KITE_REDIS_PASSWORD`：外部 Redis 密码（可选）
+
+## 对外暴露
+
+- **注册中心**：发布 Redis 连接信息（host、port、protocol）
+- **RPC 接口**：提供基础 Redis 操作（GET/SET/HGET/HSET 等）
+- **事件**：`system.redis_ready` — Redis 可用时发布
+
+## 支持的命令
+
+GET, SET, DEL, EXPIRE, HGET, HSET, HDEL, HGETALL, SADD, SREM, SMEMBERS, PUBLISH, SUBSCRIBE, PING