perf(core): reduce execution projection and dispatch overhead (#2746)

* perf(core): join execution projection and reuse authorized tool schemas * perf(pipeline): avoid duplicate checks before stage output validation * perf(plugin): reuse reconciled settings within event dispatch * fix(workspace): keep execution projection reads free of unrelated flushes
2026-10-27 02:45:24 +08:00 · 2026-10-22 20:00:42 +08:00
parent 2c59bc2c55
commit cc19395f5c
12 changed files with 396 additions and 49 deletions
@@ -1,5 +1,7 @@
 from __future__ import annotations

+import typing
+
 import sqlalchemy
 from sqlalchemy.ext.asyncio import AsyncSession

@@ -13,6 +15,26 @@ from ..entity.persistence.workspace import (
 )


+_WORKSPACE_COLUMNS = Workspace.__table__.c
+_EXECUTION_COLUMNS = WorkspaceExecutionState.__table__.c
+_EXECUTION_PROJECTION = (
+    sqlalchemy.select(
+        _WORKSPACE_COLUMNS.uuid,
+        _WORKSPACE_COLUMNS.instance_uuid,
+        _WORKSPACE_COLUMNS.source,
+        _WORKSPACE_COLUMNS.status,
+        _WORKSPACE_COLUMNS.created_at,
+        _EXECUTION_COLUMNS.instance_uuid.label('execution_instance_uuid'),
+        _EXECUTION_COLUMNS.active_generation,
+        _EXECUTION_COLUMNS.state,
+        _EXECUTION_COLUMNS.write_fenced,
+        _EXECUTION_COLUMNS.source.label('execution_source'),
+    )
+    .outerjoin(WorkspaceExecutionState.__table__, _EXECUTION_COLUMNS.workspace_uuid == _WORKSPACE_COLUMNS.uuid)
+    .where(_WORKSPACE_COLUMNS.uuid == sqlalchemy.bindparam('workspace_uuid'))
+)
+
+
 class WorkspaceRepository:
    """Transaction-bound persistence operations for the workspace directory."""

@@ -46,6 +68,49 @@ class WorkspaceRepository:
    async def get_workspace(self, workspace_uuid: str) -> Workspace | None:
        return await self.session.get(Workspace, workspace_uuid)

+    async def get_execution_projection(self, workspace_uuid: str) -> dict[str, typing.Any] | None:
+        """Read current fencing records without flushing caller-owned writes."""
+        with self.session.no_autoflush:
+            result = await self.session.execute(_EXECUTION_PROJECTION, {'workspace_uuid': workspace_uuid})
+        row = result.mappings().first()
+        if row is None:
+            return None
+        projection = dict(row)
+        for entity in self.session.new | self.session.deleted:
+            if isinstance(entity, Workspace) and (
+                entity.uuid == workspace_uuid or sqlalchemy.inspect(entity).identity == (workspace_uuid,)
+            ):
+                # New and deleted directory records cannot authorize execution.
+                return None
+            if isinstance(entity, WorkspaceExecutionState) and (
+                entity.workspace_uuid == workspace_uuid or sqlalchemy.inspect(entity).identity == (workspace_uuid,)
+            ):
+                projection['execution_instance_uuid'] = None
+        for entity in self.session.dirty:
+            if not isinstance(entity, (Workspace, WorkspaceExecutionState)):
+                continue
+            state = sqlalchemy.inspect(entity)
+            if state.identity != (workspace_uuid,):
+                continue
+            identity_field = 'uuid' if isinstance(entity, Workspace) else 'workspace_uuid'
+            if state.attrs[identity_field].history.has_changes():
+                return None
+            if isinstance(entity, Workspace):
+                fields = {name: name for name in ('uuid', 'instance_uuid', 'source', 'status', 'created_at')}
+            else:
+                fields = {
+                    'instance_uuid': 'execution_instance_uuid',
+                    'active_generation': 'active_generation',
+                    'state': 'state',
+                    'write_fenced': 'write_fenced',
+                    'source': 'execution_source',
+                }
+            for name, key in fields.items():
+                history = state.attrs[name].history
+                if history.has_changes():
+                    projection[key] = history.added[0] if history.added else None
+        return projection
+
    def add_workspace(self, workspace: Workspace) -> None:
        self.session.add(workspace)

@@ -231,7 +231,8 @@ class WorkspaceService:
                )

        async def operation(repository: WorkspaceRepository) -> WorkspaceExecutionBinding:
-            if workspace_uuid is None:
+            selected_uuid = workspace_uuid
+            if selected_uuid is None:
                workspaces = await repository.list_local_workspaces(self.instance_uuid)
                if not workspaces:
                    raise WorkspaceNotFoundError('The local workspace has not been initialized')
@@ -239,52 +240,51 @@ class WorkspaceService:
                    raise WorkspaceInvariantError(
                        f'Expected one local workspace for {self.instance_uuid!r}, found {len(workspaces)}'
                    )
-                workspace = workspaces[0]
-            else:
-                workspace = await repository.get_workspace(workspace_uuid)
-                if workspace is None:
-                    raise WorkspaceNotFoundError(f'Workspace {workspace_uuid!r} does not exist')
+                selected_uuid = workspaces[0].uuid

-            if workspace.instance_uuid != self.instance_uuid:
-                raise WorkspaceInvariantError(f'Workspace {workspace.uuid!r} belongs to another instance')
-            if _require_local and workspace.source != WorkspaceSource.LOCAL.value:
-                raise WorkspaceInvariantError(f'Workspace {workspace.uuid!r} is not an OSS local workspace')
-            if workspace.status != WorkspaceStatus.ACTIVE.value:
-                raise WorkspaceExecutionUnavailableError(f'Workspace {workspace.uuid!r} is not active')
+            workspace = await repository.get_execution_projection(selected_uuid)
+            if workspace is None:
+                raise WorkspaceNotFoundError(f'Workspace {selected_uuid!r} does not exist')

-            execution_state = await repository.get_execution_state(workspace.uuid)
-            if execution_state is None:
-                raise WorkspaceExecutionUnavailableError(f'Workspace {workspace.uuid!r} has no execution state')
-            if execution_state.instance_uuid != self.instance_uuid:
+            if workspace['instance_uuid'] != self.instance_uuid:
+                raise WorkspaceInvariantError(f'Workspace {workspace["uuid"]!r} belongs to another instance')
+            if _require_local and workspace['source'] != WorkspaceSource.LOCAL.value:
+                raise WorkspaceInvariantError(f'Workspace {workspace["uuid"]!r} is not an OSS local workspace')
+            if workspace['status'] != WorkspaceStatus.ACTIVE.value:
+                raise WorkspaceExecutionUnavailableError(f'Workspace {workspace["uuid"]!r} is not active')
+
+            if workspace['execution_instance_uuid'] is None:
+                raise WorkspaceExecutionUnavailableError(f'Workspace {workspace["uuid"]!r} has no execution state')
+            if workspace['execution_instance_uuid'] != self.instance_uuid:
                raise WorkspaceInvariantError(
-                    f'Workspace {workspace.uuid!r} execution state belongs to another instance'
+                    f'Workspace {workspace["uuid"]!r} execution state belongs to another instance'
                )
            expected_source = (
                WorkspaceExecutionSource.LOCAL.value
-                if workspace.source == WorkspaceSource.LOCAL.value
+                if workspace['source'] == WorkspaceSource.LOCAL.value
                else WorkspaceExecutionSource.CLOUD.value
            )
-            if execution_state.source != expected_source:
+            if workspace['execution_source'] != expected_source:
                raise WorkspaceInvariantError(
-                    f'Workspace {workspace.uuid!r} execution source does not match its directory source'
+                    f'Workspace {workspace["uuid"]!r} execution source does not match its directory source'
                )
-            if execution_state.state != WorkspaceExecutionStatus.ACTIVE.value or execution_state.write_fenced:
-                raise WorkspaceExecutionUnavailableError(f'Workspace {workspace.uuid!r} execution is unavailable')
-            if execution_state.active_generation <= 0:
-                raise WorkspaceInvariantError(f'Workspace {workspace.uuid!r} has an invalid execution generation')
-            if expected_generation is not None and execution_state.active_generation != expected_generation:
+            if workspace['state'] != WorkspaceExecutionStatus.ACTIVE.value or workspace['write_fenced']:
+                raise WorkspaceExecutionUnavailableError(f'Workspace {workspace["uuid"]!r} execution is unavailable')
+            if workspace['active_generation'] <= 0:
+                raise WorkspaceInvariantError(f'Workspace {workspace["uuid"]!r} has an invalid execution generation')
+            if expected_generation is not None and workspace['active_generation'] != expected_generation:
                raise WorkspaceGenerationMismatchError(
-                    f'Workspace {workspace.uuid!r} generation {execution_state.active_generation} '
+                    f'Workspace {workspace["uuid"]!r} generation {workspace["active_generation"]} '
                    f'does not match expected generation {expected_generation}'
                )

            return WorkspaceExecutionBinding(
                instance_uuid=self.instance_uuid,
-                workspace_uuid=workspace.uuid,
-                placement_generation=execution_state.active_generation,
-                write_fenced=execution_state.write_fenced,
-                state=execution_state.state,
-                workspace_created_at=workspace.created_at,
+                workspace_uuid=workspace['uuid'],
+                placement_generation=workspace['active_generation'],
+                write_fenced=workspace['write_fenced'],
+                state=workspace['state'],
+                workspace_created_at=workspace['created_at'],
            )

        binding = await self._run(operation, session=session)