Import ECS deployed relay source and historical patches (2026-10-27)

This commit is contained in:
ex_tianzy
2026-10-27 17:26:58 +08:00
commit 011a7797ee
319 changed files with 34265 additions and 0 deletions
+116
View File
@@ -0,0 +1,116 @@
import asyncio
import contextlib
import json
import socket
import fakeredis.aioredis
import httpx
import pytest_asyncio
import uvicorn
from relay.cli import device_request, init_project, issue
from relay.config import Settings
from relay.connector import create_app as connector_app
from relay.router import create_app as router_app
class PlatformStub:
def __init__(self):
self.replies = []
self.exchanges = 0
self.refreshes = 0
async def exchange(self, code):
self.exchanges += 1
await asyncio.sleep(0.01)
return {"user_access_token": "fake-user-token", "refresh_token": "fake-refresh-token",
"expires_in": 6900, "refresh_expires_in": 2592000, "open_id": "ou_test"}
async def refresh(self, token):
self.refreshes += 1
await asyncio.sleep(0.01)
return {"user_access_token": "new-fake-token", "refresh_token": "rotated-fake-token",
"expires_in": 7200, "open_id": "ou_test"}
async def user_info(self, token):
return {"open_id": "ou_test"}
async def reply(self, message, text):
self.replies.append((message, text))
async def close(self):
pass
async def serve(app):
sock = socket.socket()
sock.bind(("127.0.0.1", 0))
sock.listen(128)
port = sock.getsockname()[1]
server = uvicorn.Server(uvicorn.Config(app, log_level="critical", access_log=False, lifespan="on"))
task = asyncio.create_task(server.serve(sockets=[sock]))
for _ in range(200):
if server.started:
return server, task, port
if task.done():
task.result()
raise RuntimeError("server failed")
await asyncio.sleep(0.01)
raise RuntimeError("server startup timeout")
@pytest_asyncio.fixture
async def env(tmp_path):
init_project(tmp_path, "localhost")
settings = Settings(environment="test", admin_secret="a" * 40, internal_secret="b" * 40,
data_dir=tmp_path / "runtime/connector", ca_cert=tmp_path / "runtime/trust/ca.pem",
connector_key=tmp_path / "runtime/connector/connector.key",
connector_public_key=tmp_path / "runtime/trust/connector.pub",
feishu_enabled=True, feishu_app_id="cli_test", feishu_app_secret="fake-app-secret",
feishu_encrypt_key="fake-encrypt-key", feishu_verification_token="fake-verification",
public_url="http://localhost", router_url="ws://localhost/device/ws", request_timeout=2)
redis = fakeredis.aioredis.FakeRedis(decode_responses=True)
platform = PlatformStub()
connector = connector_app(settings, redis=redis, platform=platform)
router = router_app(settings, redis=redis)
cs, ct, cp = await serve(connector)
rs, rt, rp = await serve(router)
client = httpx.AsyncClient(base_url=f"http://127.0.0.1:{cp}", timeout=10)
state = {"settings": settings, "redis": redis, "platform": platform, "connector": connector,
"router": router, "client": client, "root": tmp_path,
"connector_url": f"http://127.0.0.1:{cp}", "router_url": f"ws://127.0.0.1:{rp}/device/ws",
"admin": {"X-Admin-Secret": settings.admin_secret}, "tasks": []}
yield state
for task in state["tasks"]:
task.cancel()
await asyncio.gather(*state["tasks"], return_exceptions=True)
await client.aclose()
cs.should_exit = rs.should_exit = True
await asyncio.wait_for(asyncio.gather(ct, rt), timeout=10)
await redis.aclose()
async def provision(env, owner="ou_test"):
directory = env["root"] / owner
device_request(directory)
output = env["root"] / (owner + "-issued")
issue(env["root"], directory / "request.json", output)
for name in ["device.pem", "ca.pem", "connector.pub", "device.json"]:
(directory / name).write_bytes((output / name).read_bytes())
registration = json.loads((output / "registration.json").read_text())
response = await env["client"].post("/admin/devices", json=registration, headers=env["admin"])
assert response.status_code == 201, response.text
response = await env["client"].post("/admin/test/binding-code", json={"open_id": owner, "text": "ignored"}, headers=env["admin"])
code = response.json()["message"].split(":")[-1]
from relay.device import bind_device
await bind_device(directory, env["connector_url"], code)
return directory, registration["host_id"]
async def connect_device(env, directory, root=None):
from relay.device import run_device
connected = asyncio.Event()
task = asyncio.create_task(run_device(directory, env["router_url"], root=root, connected_event=connected))
env["tasks"].append(task)
await asyncio.wait_for(connected.wait(), 5)
return task