172 lines
11 KiB
Python
172 lines
11 KiB
Python
import json
|
|
from datetime import timedelta
|
|
from django.db import transaction
|
|
from django.utils import timezone
|
|
from rest_framework.views import APIView
|
|
from rest_framework.exceptions import ValidationError, PermissionDenied, NotFound
|
|
from common.log.log import log
|
|
from common.auth import TokenAuth
|
|
from common.result import result
|
|
from system_manage import ai_hub as hub, mcp_registry as registry, mcp_scheduler as scheduler, mcp_workflows
|
|
from system_manage.models.ai_hub import AITask, AIFlow
|
|
|
|
|
|
def task_data(task, detail=False):
|
|
data = {'id': str(task.id), 'name': task.name, 'status': task.status, 'attempt': task.attempt,
|
|
'priority': task.snapshot.get('priority', 5), 'resources': scheduler.resources(task),
|
|
'created_at': task.created_at, 'started_at': task.started_at, 'finished_at': task.finished_at,
|
|
'error': task.error, 'dispatch': task.snapshot.get('dispatch', 'worker'),
|
|
'application_id': task.snapshot.get('application_id'), 'application_version': task.snapshot.get('application_version'),
|
|
'trace': task.snapshot.get('trace', {}), 'source': task.snapshot.get('source'),
|
|
'waiting_reason': '等待资源或执行器' if task.status == 'PENDING' else ''}
|
|
if detail:
|
|
data.update(steps=task.steps, result=task.result)
|
|
return data
|
|
|
|
|
|
class EngineView(APIView):
|
|
authentication_classes = [TokenAuth]
|
|
|
|
def initial(self, request, *args, **kwargs):
|
|
super().initial(request, *args, **kwargs)
|
|
from users.serializers.user import get_workspace_list_by_user
|
|
from system_manage.platform_access import module_list
|
|
if not request.user.is_active or kwargs['workspace_id'] not in {str(w['id']) for w in get_workspace_list_by_user(request.user.id)}:
|
|
raise PermissionDenied('无权访问当前工作空间')
|
|
if not {'application', 'mindmap', 'tool'} & set(module_list(request.user)):
|
|
raise PermissionDenied('未授权使用组件编排')
|
|
|
|
def get(self, request, workspace_id, kind):
|
|
user = request.user
|
|
if kind == 'workbench_flows':
|
|
return result.success(mcp_workflows.workbench_flows(workspace_id, user))
|
|
if kind == 'components':
|
|
rows = registry.catalogue(workspace_id, user)
|
|
running = AITask.objects.filter(status='RUNNING').only('snapshot')
|
|
from collections import Counter
|
|
counts = Counter(key for task in running for key in scheduler.resources(task))
|
|
return result.success({'records': [{**row, 'running': counts[row['id']]} for row in rows],
|
|
'capacity': registry.settings_row().meta.get('capacity', 4),
|
|
'interactive_reserve': registry.settings_row().meta.get('interactive_reserve', 1), 'worker_online': scheduler.worker_online(), 'is_admin': hub.admin(user)})
|
|
if kind == 'flows':
|
|
from application.models import Application
|
|
query = Application.objects.filter(workspace_id=workspace_id, type='WORK_FLOW')
|
|
if not hub.admin(user): query = query.filter(user_id=user.id)
|
|
apps = [{'id': str(app.id), 'name': app.name, 'kind': 'application', 'published': app.is_publish,
|
|
'updated_at': app.update_time} for app in query.order_by('-update_time')[:200]]
|
|
flows = hub.visible(AIFlow.objects.filter(workspace_id=workspace_id), user)
|
|
return result.success(apps + [{'id': str(flow.id), 'name': flow.name, 'kind': 'mindmap', 'published': True,
|
|
'revision': flow.revision, 'updated_at': flow.updated_at} for flow in flows.order_by('-updated_at')[:200]])
|
|
if kind == 'tasks':
|
|
from rest_framework import serializers
|
|
class Query(serializers.Serializer):
|
|
page = serializers.IntegerField(default=1, min_value=1)
|
|
page_size = serializers.IntegerField(default=20, min_value=1, max_value=100)
|
|
status = serializers.ChoiceField(choices=['', 'PENDING', 'RUNNING', 'SUCCESS', 'FAILED', 'CANCELLED'], required=False)
|
|
query = Query(data=request.query_params); query.is_valid(raise_exception=True)
|
|
params = query.validated_data
|
|
tasks = AITask.objects.filter(workspace_id=workspace_id)
|
|
if not hub.admin(user):
|
|
from django.db.models import Q
|
|
tasks = tasks.filter(Q(owner_id=user.id) | Q(snapshot__trace__viewer_id=str(user.id)))
|
|
if params.get('status'): tasks = tasks.filter(status=params['status'])
|
|
for key in ('application_id', 'chat_id', 'chat_record_id'):
|
|
if request.query_params.get(key):
|
|
value = str(serializers.UUIDField().run_validation(request.query_params[key]))
|
|
from django.db.models import Q
|
|
tasks = tasks.filter(Q(**{'snapshot__trace__' + key: value}) | Q(**{'snapshot__' + key: value}))
|
|
if request.query_params.get('id'):
|
|
pk = serializers.UUIDField().run_validation(request.query_params['id'])
|
|
task = tasks.filter(pk=pk).first()
|
|
if not task: raise NotFound('任务不存在')
|
|
return result.success(task_data(task, detail=True))
|
|
total, size = tasks.count(), params['page_size']
|
|
page = min(params['page'], max(1, (total + size - 1) // size))
|
|
records = tasks.defer('file_data', 'input_data', 'result', 'steps').order_by('-created_at', '-id')[(page-1)*size:page*size]
|
|
return result.success({'records': [task_data(task) for task in records], 'total': total, 'current': page})
|
|
raise NotFound()
|
|
|
|
@log(menu='MCP引擎', operate='管理组件与任务', get_details=lambda request: {
|
|
'kind': request.path.rsplit('/', 1)[-1], **{key: request.data.get(key) for key in ('id', 'state', 'capacity', 'priority') if key in request.data}})
|
|
def post(self, request, workspace_id, kind):
|
|
data = request.data
|
|
if request.FILES:
|
|
try: data = json.loads(request.data.get('data', '{}'))
|
|
except (ValueError, TypeError): raise ValidationError('任务参数无效')
|
|
if not isinstance(data, dict): raise ValidationError('请求参数无效')
|
|
user = request.user
|
|
if kind == 'components':
|
|
return result.success(registry.configure(workspace_id, user, data.get('id', ''), data))
|
|
if kind == 'recover':
|
|
hub.require_admin(user)
|
|
return result.success({'recovered': scheduler.recover()})
|
|
if kind == 'capacity':
|
|
hub.require_admin(user)
|
|
with transaction.atomic():
|
|
row = registry.settings_row(lock=True)
|
|
row.meta = {**row.meta, 'capacity': hub.integer(data.get('capacity'), 1, 32, '总执行容量'),
|
|
'interactive_reserve': hub.integer(data.get('interactive_reserve', 1), 0, 31, '交互预留容量')}
|
|
row.save(update_fields=['meta', 'update_time'])
|
|
return result.success(True)
|
|
if kind == 'probe':
|
|
hub.require_admin(user)
|
|
metadata, obj = registry.resolve(workspace_id, user, data.get('id', ''), check=False)
|
|
health = 'READY'
|
|
try:
|
|
if metadata['kind'] == 'parser': hub.parser_test(obj)
|
|
elif metadata['kind'] == 'mcp' and obj:
|
|
from system_manage.mcp_runtime import discover
|
|
discover(obj.code)
|
|
elif metadata['kind'] == 'model': health = 'CONFIGURED'
|
|
elif metadata['id'] == 'mcp-custom': health = 'CONFIGURED'
|
|
except Exception:
|
|
health = 'UNREACHABLE'
|
|
with transaction.atomic():
|
|
row = registry.settings_row(lock=True)
|
|
components = row.meta.setdefault('components', {})
|
|
components[metadata['id']] = {**components.get(metadata['id'], {}), 'health': health,
|
|
'checked_at': timezone.now().isoformat()}
|
|
row.save(update_fields=['meta', 'update_time'])
|
|
return result.success({'health': health})
|
|
if kind == 'tools':
|
|
from system_manage.mcp_runtime import discover
|
|
key = data.get('id', '')
|
|
_, obj = registry.resolve(workspace_id, user, key)
|
|
if not key.startswith('mcp:'):
|
|
raise ValidationError('请选择已注册的 MCP 工具')
|
|
return result.success(discover(obj.code))
|
|
if kind == 'flows':
|
|
app = mcp_workflows.new_template(workspace_id, user, data)
|
|
return result.success({'id': str(app.id)})
|
|
if kind == 'tasks':
|
|
if data.get('flow_kind') == 'mindmap':
|
|
from system_manage.platform_access import module_list
|
|
if 'mindmap' not in module_list(user): raise PermissionDenied('未授权使用思维导图')
|
|
task = hub.submit(workspace_id, user, {'flow_id': data.get('flow_id'), 'markdown': data.get('question', ''),
|
|
'priority': data.get('priority', 5)}, request.FILES.get('file'), request=request)
|
|
else:
|
|
from system_manage.access_control import enforce
|
|
enforce(request, 'application', data.get('application_id'))
|
|
task = mcp_workflows.submit(workspace_id, user, data, request.FILES.get('file'))
|
|
return result.success(task_data(task))
|
|
if kind in ('cancel', 'retry', 'priority'):
|
|
with transaction.atomic():
|
|
task = hub.one('tasks', data.get('id'), workspace_id, user, edit=True, lock=True)
|
|
if kind == 'cancel': scheduler.cancel(task)
|
|
elif kind == 'priority':
|
|
if task.status != 'PENDING': raise ValidationError('仅排队任务可调整优先级')
|
|
task.snapshot = {**task.snapshot, 'priority': hub.integer(data.get('priority'), 0, 9, '优先级')}
|
|
task.save(update_fields=['snapshot', 'updated_at'])
|
|
else:
|
|
if task.status not in ('FAILED', 'CANCELLED'): raise ValidationError('仅失败或取消的任务可重试')
|
|
if task.snapshot.get('dispatch') == 'inline': raise ValidationError('请在原高级编排中重新运行该节点')
|
|
for key in scheduler.resources(task): registry.resolve(workspace_id, user, key)
|
|
if AITask.objects.filter(owner_id=user.id, status__in=scheduler.ACTIVE).count() >= 10:
|
|
raise ValidationError('待处理任务已达上限')
|
|
task.status, task.error, task.steps = 'PENDING', '', []
|
|
task.attempt += 1
|
|
task.started_at = task.finished_at = None
|
|
task.save()
|
|
return result.success(True)
|
|
raise NotFound()
|