"""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