"""Optional official SDK event source, private platform domain explicitly configured.""" import json import logging import os import threading import time from concurrent.futures import ThreadPoolExecutor,TimeoutError as FutureTimeout import httpx import redis from .config import Settings def safe_card_callback_response(payload): """Forward only code-owned terminal cards returned after verified decisions.""" from .approval_cards import decision_response_card fallback={'toast':{'type':'warning','content':'确认结果待核对,请查看任务状态。'}} if not isinstance(payload,dict):return fallback toast=payload.get('toast') if (not isinstance(toast,dict)or toast.get('type')not in {'info','success','warning','error'} or not isinstance(toast.get('content'),str)or len(toast['content'])>200):return fallback response={'toast':{'type':toast['type'],'content':toast['content']}} card=payload.get('card') if card is not None: allowed=[{'type':'raw','data':decision_response_card(state)}for state in ('approved','rejected','expired','cancelled','consumed')] if card not in allowed:return fallback response['card']=card return response 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) builder = lark.EventDispatcherHandler.builder("", "").register_p2_im_message_receive_v1(received) callback_pool=None if s.work_remote_approvals_enabled: from lark_oapi.event.callback.model.p2_card_action_trigger import P2CardActionTriggerResponse callback_pool=ThreadPoolExecutor(max_workers=2,thread_name_prefix='work-card-callback') callback_slots=threading.BoundedSemaphore(2) def forward_card(raw): deadline=time.monotonic()+2.1 # Own this client until the worker ends. The SDK response deadline # does not imply an in-flight authenticated decision was rolled back. with httpx.Client(base_url=url,trust_env=False,follow_redirects=False, timeout=httpx.Timeout(.8,connect=.2,pool=.1))as callback_http: with callback_http.stream('POST','/internal/approval-callback',content=raw, headers={'X-Internal-Secret':s.internal_secret,'Content-Type':'application/json'})as response: if response.status_code!=200:raise ValueError() body=bytearray() for chunk in response.iter_bytes(): body.extend(chunk) if len(body)>4096 or time.monotonic()>deadline:raise ValueError() return json.loads(body) def decision(event): # Same authenticated SDK connection/lease, no second consumer. # Never log callback bodies or the card-update credential. fallback={'toast':{'type':'warning','content':'确认结果待核对,请查看原任务状态。'}} try: raw=lark.JSON.marshal(event).encode('utf-8') if len(raw)>65536:return P2CardActionTriggerResponse(fallback) if not callback_slots.acquire(blocking=False):return P2CardActionTriggerResponse(fallback) try:future=callback_pool.submit(forward_card,raw) except BaseException: callback_slots.release() raise def settled(completed): callback_slots.release() if not completed.cancelled():completed.exception() future.add_done_callback(settled) try:payload=future.result(timeout=2.3) except FutureTimeout:return P2CardActionTriggerResponse(fallback) return P2CardActionTriggerResponse(safe_card_callback_response(payload)) except Exception:return P2CardActionTriggerResponse(fallback) builder=builder.register_p2_card_action_trigger(decision) handler=builder.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() if callback_pool:callback_pool.shutdown(wait=False,cancel_futures=True) 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