131 lines
6.3 KiB
Python
131 lines
6.3 KiB
Python
"""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 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)
|
|
toast=payload.get('toast')if isinstance(payload,dict)else None
|
|
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 P2CardActionTriggerResponse(fallback)
|
|
return P2CardActionTriggerResponse({'toast':toast})
|
|
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
|