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

107 lines
5.1 KiB
Python

"""Opt-in device-authenticated approval API, with no business execution route."""
import asyncio
from fastapi import APIRouter,HTTPException,Request
from fastapi.responses import JSONResponse
from pydantic import Field
from .approval_callback import ApprovalCallbackVerifier,decision_toast
from .approval_cards import ApprovalCardSender
from .approval_policy import describe_action
from .approval_store import ApprovalError
from .common import no_cache,require_secret
from .task_delivery import TaskRequest
class CreateApproval(TaskRequest):
operation_id:str=Field(pattern=r'^[A-Za-z0-9_-]{8,100}$')
action:dict=Field(repr=False)
ttl:int=Field(default=120,strict=True,ge=30,le=600)
class ApprovalReference(TaskRequest):
approval_id:str=Field(pattern=r'^apr_[a-f0-9]{64}$')
operation_digest:str=Field(pattern=r'^[a-f0-9]{64}$')
class ApprovalAPI:
def __init__(self,auth,worker,platform,spawn):
self.auth,self.worker,self.spawn=auth,worker,spawn
self.sender=ApprovalCardSender(worker,platform)
self.scheduled=set()
s=auth.s
self.verifier=ApprovalCallbackVerifier(environment=s.environment,app_id=s.feishu_app_id,
tenant_key=s.feishu_tenant_key,verification_token=s.feishu_verification_token,
internal_secret=s.internal_secret,encrypt_key=s.feishu_encrypt_key)
self.router=APIRouter()
for name in ('create','status','consume','cancel'):
self.router.add_api_route('/work/v2/approvals/'+name,getattr(self,name),methods=['POST'])
self.router.add_api_route('/internal/approval-callback',self.callback,methods=['POST'])
async def _call(self,method,*args):
try:return await self.worker.call(method,*args)
except ApprovalError:
raise HTTPException(409,'approval_unavailable_or_unconfirmed')from None
def _schedule(self,kind,approval_id):
key=(kind,approval_id)
if key in self.scheduled or len(self.scheduled)>=32:return
self.scheduled.add(key)
async def deliver():
try:
if kind=='send':await self.sender.send(approval_id)
else:await self.sender.update_closed(approval_id)
finally:self.scheduled.discard(key)
self.spawn(deliver())
async def create(self,body:CreateApproval,request:Request):
await self.auth.authenticate(body,request)
try:summary,impact=describe_action(body.action)
except (ApprovalError,TypeError,ValueError,RecursionError):
raise HTTPException(400,'unsupported_approval_action')from None
result=await self._call('create',body.task_id,body.binding_owner,body.host_id,
body.binding_generation,body.operation_id,body.action,summary,impact,body.ttl)
self._schedule('send',result['approval_id'])
return no_cache(JSONResponse(result))
async def _reference(self,method,body,request):
await self.auth.authenticate(body,request)
args=(body.approval_id,body.task_id,body.binding_owner,body.host_id,body.binding_generation)
# Cancel requires the same request digest too, not just visibility of an ID.
if method=='cancel':
await self._call('status',*args,body.operation_digest)
result=await self._call('cancel',*args)
else:result=await self._call(method,*args,body.operation_digest)
if method in {'consume','cancel'}:self._schedule('close',body.approval_id)
return no_cache(JSONResponse(result))
async def status(self,body:ApprovalReference,request:Request):
return await self._reference('status',body,request)
async def consume(self,body:ApprovalReference,request:Request):
return await self._reference('consume',body,request)
async def cancel(self,body:ApprovalReference,request:Request):
return await self._reference('cancel',body,request)
async def callback(self,request:Request):
if self.auth.s.feishu_event_source!='longconn':raise HTTPException(404,'not_found')
supplied=request.headers.get('X-Internal-Secret','')
require_secret(supplied,self.auth.s.internal_secret)
try:
raw=await asyncio.wait_for(request.body(),timeout=.2)
decision=self.verifier.from_sdk_channel(raw,supplied)
result=await self.worker.call('decide',decision)
except (ApprovalError,asyncio.TimeoutError):
return no_cache(JSONResponse({'toast':{'type':'warning',
'content':'确认未完成或结果待核对,请查看原任务状态,勿重复发起操作。'}}))
self._schedule('close',decision.approval_id)
return no_cache(JSONResponse(decision_toast(result)))
async def maintain(self):
await self.worker.call('close_unavailable')
for approval_id in await self.worker.call('cards_to_send'):self._schedule('send',approval_id)
for approval_id in await self.worker.call('cards_to_close'):self._schedule('close',approval_id)
if self.auth.s.approval_retention_enabled:
await self.worker.call('maintain_retention',self.auth.s.approval_payload_retention_days,
self.auth.s.approval_audit_retention_days)