Files
ecs-relay-service/deployable/relay/longconn.py

84 lines
3.3 KiB
Python

"""Optional official SDK event source, private platform domain explicitly configured."""
import json
import logging
import os
import threading
import time
import httpx
import redis
from .config import Settings
def disable_proxy_environment():
"""This dedicated SDK worker must connect directly, including discovery and WS."""
for key in ("HTTP_PROXY", "HTTPS_PROXY", "ALL_PROXY", "http_proxy", "https_proxy", "all_proxy"):
os.environ.pop(key, None)
os.environ["NO_PROXY"] = "*"
os.environ["no_proxy"] = "*"
def main():
disable_proxy_environment()
import lark_oapi as lark
s = Settings(role="longconn")
if not s.feishu_enabled or s.feishu_event_source != "longconn":
raise RuntimeError("platform is disabled")
# The SDK may log websocket URLs, tokens or event bodies. Disable its logging entirely.
logging.disable(logging.CRITICAL)
r = redis.Redis.from_url(s.redis_url)
lease = r.lock("hn:longconn:leader", timeout=30, thread_local=False)
if not lease.acquire(blocking=False):
raise RuntimeError("another long-connection consumer owns the lease")
url = os.environ.get("HN_CONNECTOR_INTERNAL_URL", "http://connector:8000")
client = httpx.Client(base_url=url, timeout=10, follow_redirects=False, trust_env=False)
done = threading.Event()
def maintain_lease():
while not done.wait(8):
try:
lease.extend(30, replace_ttl=True)
except Exception:
# Fail closed. Continuing after lease loss could create two consumers.
os._exit(2)
threading.Thread(target=maintain_lease, daemon=True).start()
def received(event):
data = json.loads(lark.JSON.marshal(event))
response = client.post("/internal/events", headers={"X-Internal-Secret": s.internal_secret}, json=data)
if response.status_code != 200:
raise RuntimeError("connector did not accept event")
print(json.dumps({"event": "platform_event_accepted", "type": data.get("header", {}).get("event_type")}), flush=True)
handler = lark.EventDispatcherHandler.builder("", "").register_p2_im_message_receive_v1(received).build()
class ObservableClient(lark.ws.Client):
async def _connect(self):
try:
await super()._connect()
if self._conn is not None:
print(json.dumps({"event": "platform_connected", "api_host": s.feishu_api_base}), flush=True)
except Exception as error:
print(json.dumps({"event": "platform_connect_failed", "error_type": type(error).__name__}), flush=True)
raise
try:
# domain is an actual supported SDK argument; no public-cloud-domain monkey patch.
ObservableClient(s.feishu_app_id, s.feishu_app_secret, event_handler=handler,
domain=s.feishu_api_base.rstrip("/"), log_level=lark.LogLevel.ERROR).start()
finally:
done.set()
client.close()
try:
lease.release()
except redis.exceptions.LockError:
pass
if __name__ == "__main__":
try:
main()
except Exception as error:
print(json.dumps({"event": "platform_consumer_stopped", "error_type": type(error).__name__}), flush=True)
raise SystemExit(1) from None