Extract the Nexus runtime from Tessera
This commit is contained in:
+7
-6
@@ -9,11 +9,13 @@
|
||||
| 目录 | 责任 |
|
||||
| --- | --- |
|
||||
| `shell/` | 原生工作区、窗口输入、标签、开发工具和独立宿主管理控件 |
|
||||
| `runtime/` | 本机 API、串行 VM 执行、事件和异步任务 |
|
||||
| `runtime/` | Tessera 运行时适配:本机 API/worker、UI 输入与发布;通用执行由 Nexus 提供 |
|
||||
| `model/` | 托管对象、绑定、Mount、窗口语义、依赖与发布值 |
|
||||
| `render/` | 几何、布局、source/native 视觉协议、绘制、命中、字体和软件渲染 |
|
||||
| `bridge/` | Endor 类型/方法与宿主能力及展示刷新之间的连接 |
|
||||
|
||||
通用源码、编译、Console 历史/预算、VM 根、任务和驱动实现见 [本地 Nexus](../vendor/nexus/README.md);[抽取边界](../docs/architecture/nexus-extraction.md)区分实现接入与尚未执行的编译/回归。
|
||||
|
||||
## shell
|
||||
|
||||
| 模块 | 职责 |
|
||||
@@ -33,13 +35,11 @@
|
||||
| 模块 | 职责 |
|
||||
| --- | --- |
|
||||
| [api](runtime/api.rs) | HTTP 请求路由、队列、请求观察和响应;worker/指南拆为子模块 |
|
||||
| [endor_host](runtime/endor_host.rs) | 候选/活跃 VM、编译执行、增量刷新、清理和诊断 |
|
||||
| [endor_script](runtime/endor_script.rs) | 组织 Aster Script/Module 输入及原始源码范围 |
|
||||
| [endor_host](runtime/endor_host.rs) | 组合 Nexus 会话与 Tessera UI 桥接,维护代码投影、增量刷新和发布 |
|
||||
| [events](runtime/events.rs) | 原生输入的有界 loopback 传输 |
|
||||
| [event_dispatch](runtime/event_dispatch.rs) | 托管事件、订阅和 capture/target/bubble 分发 |
|
||||
| [io_tasks](runtime/io_tasks.rs) | 有界文件/HTTP provider、纯数据完成消息和取消 |
|
||||
| [tasks](runtime/tasks.rs) | 托管 Task、owner/key 取消和协作任务调度 |
|
||||
| [vm_sequence](runtime/vm_sequence.rs) | 共享 VM 调用序列及同帧迭代驱动 |
|
||||
| [tasks](runtime/tasks.rs) | 为 Nexus 任务引擎提供 UI owner 作用域、窗口/页面资格和 Task 类型 |
|
||||
| [vm_sequence](runtime/vm_sequence.rs) | 为 Nexus 的共享调用驱动附着 Tessera Function 名义类型 |
|
||||
|
||||
## model
|
||||
|
||||
@@ -76,6 +76,7 @@
|
||||
|
||||
| 模块 | 职责 |
|
||||
| --- | --- |
|
||||
| [nexus_host](bridge/nexus_host.rs) | 向 Nexus 的真实 VM 注册 UI 领域类型与全局能力 |
|
||||
| [ui_bridge](bridge/ui_bridge.rs) | Endor 宿主类型、窗口展示会话、布局/绘制发布协调 |
|
||||
|
||||
## 主要入口和运行约束
|
||||
|
||||
@@ -319,7 +319,7 @@ impl NativeCallable for Function {
|
||||
Value::Object(resource)
|
||||
}
|
||||
ReadText => {
|
||||
// 同步读取小型资源文本供模型初始化使用;后台异步读取仍走 runtime/io_tasks 的接口。
|
||||
// 同步读取小型资源文本供模型初始化使用;后台异步读取由 Nexus io_tasks 的 provider 和任务引擎处理。
|
||||
if cx.store().is_read_only() {
|
||||
return Err(invalid("load resources outside paint/layout"));
|
||||
}
|
||||
|
||||
@@ -8,3 +8,6 @@ pub(crate) mod ui_bridge;
|
||||
/// 注册图片、字体、文字流与避让形状能力,并把托管绘制参数解码为可跨线程使用的不可变资源。
|
||||
/// ui_bridge 安装时调用注册入口,source_paint 解码 image 命令时复用图像检查。
|
||||
pub(crate) mod graphics;
|
||||
|
||||
/// 实现 Nexus 宿主注册协议,把 Tessera UI 类型与全局能力安装到同一 VM。
|
||||
pub(crate) mod nexus_host;
|
||||
|
||||
@@ -0,0 +1,24 @@
|
||||
//! Tessera 向 Nexus 注册 UI 能力的唯一生产安装适配器;Nexus 不引用本模块或 UiBridge。
|
||||
use anyhow::Result;
|
||||
use endor_core::{ObjectRef, Vm};
|
||||
|
||||
/// 每个新会话安装一份 UI 类型/方法域,实际根交给 Nexus 会话统一持有和清理。
|
||||
pub(crate) struct UiHost;
|
||||
|
||||
impl nexus::HostRegistration for UiHost {
|
||||
type Installed = super::ui_bridge::UiBridge;
|
||||
|
||||
/// Nexus 在已建立 globals 的 owning VM 上调用;失败由会话 Drop 清理半完成安装根。
|
||||
fn register(
|
||||
&self,
|
||||
vm: &mut Vm,
|
||||
roots: &mut Vec<ObjectRef>,
|
||||
globals: ObjectRef,
|
||||
) -> Result<Self::Installed> {
|
||||
// 类型、原生方法、任务域仍由 Tessera 定义,不把其 UI 规则移入通用库。
|
||||
let bridge = super::ui_bridge::install(vm, roots)?;
|
||||
// 全局别名引用刚安装的同一批名义对象,不为每条脚本重新创建类型域。
|
||||
bridge.install_globals(vm, globals)?;
|
||||
Ok(bridge)
|
||||
}
|
||||
}
|
||||
+1
-3
@@ -21,9 +21,7 @@ pub(crate) use render::{
|
||||
box_model, display_list, geometry, layout, native_visual, page, scene, scene3d, scroll,
|
||||
software_renderer, source_hit, source_layout, source_paint, text, viewport,
|
||||
};
|
||||
pub(crate) use runtime::{
|
||||
api, endor_host, endor_script, event_dispatch, events, io_tasks, tasks, vm_sequence,
|
||||
};
|
||||
pub(crate) use runtime::{api, endor_host, event_dispatch, events, tasks, vm_sequence};
|
||||
#[cfg(target_os = "macos")]
|
||||
pub(crate) use shell::native_chrome;
|
||||
pub(crate) use shell::{
|
||||
|
||||
+151
-573
File diff suppressed because it is too large
Load Diff
+224
-182
File diff suppressed because it is too large
Load Diff
@@ -1,267 +0,0 @@
|
||||
//! 区分完整 Module 与顶层 Script,并保留输入源码位置。
|
||||
//! 解析包装或片段拼接产生的 span 偏移要递归修正,保证诊断和 Sources 视图仍指向用户原始行列。
|
||||
//!
|
||||
//! runtime::endor_host 的一次性 compile 和持久会话加载调用 parse,再按 roots 进行 AST 预算检查与编译。
|
||||
//! 语句、词法和 AST 定义属于 Aster;这里只把完整源码组织成 Module 或连续 Interactive 输入。
|
||||
//! 片段先用局部字节位置解析,shift_* 递归加回起点,编译错误和 Sources 浏览才能仍对应原文件。
|
||||
use anyhow::Result;
|
||||
use frontend::{
|
||||
ParseMode, SourceUnit, Span, TokenKind,
|
||||
ast::{AstRoot, Decl, DeclKind, Expr, ExprKind, InteractiveInput, Stmt, StmtKind},
|
||||
};
|
||||
|
||||
/// 待编译输入是完整模块还是顶层脚本;两者保留不同根结构但使用统一后续接口。
|
||||
pub enum SourcePlan {
|
||||
// 保留 Aster 完整模块根,后续作为一个编译/执行单元,不拆开函数或类的定义体。
|
||||
Module(AstRoot),
|
||||
// 顶层脚本按完整交互输入连续执行;各段仍共享所属运行时的全局环境,而非各建一个 VM。
|
||||
Script(Vec<AstRoot>),
|
||||
}
|
||||
|
||||
impl SourcePlan {
|
||||
/// endor_host 的 AST 预算访问和 compile_plan 调用,借用统一根切片,不克隆 AST 或重新解析。
|
||||
pub fn roots(&self) -> &[AstRoot] {
|
||||
match self {
|
||||
// 单模块以单元素切片适配,让调用方不必维护两套遍历分支。
|
||||
Self::Module(root) => std::slice::from_ref(root),
|
||||
// 脚本直接保留原输入段顺序,声明和后续使用语句的先后关系不能重排。
|
||||
Self::Script(roots) => roots,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// endor_host 执行入口调用,优先接受完整 Module,失败则按顶层换行候选边界拼出 Aster 可解析的交互输入。
|
||||
/// 模块解析失败本身不立即作为最终错误:普通顶层脚本本就需要走后面的 Interactive 解析路径。
|
||||
/// 这里只产出 AST 计划,不执行已接受的片段;endor_host 先完成所有根的预算检查和编译,再进入源代码执行。
|
||||
pub fn parse(source: &SourceUnit) -> Result<SourcePlan> {
|
||||
// 完整模块优先;只有模块解析失败才退回连续交互输入模式,宿主不自行实现 Endor 语法。
|
||||
if let Ok(module) = frontend::parse_source_ast(source, ParseMode::Module) {
|
||||
// 模块成功就不再按行切分,避免破坏跨行声明与完整模块语义。
|
||||
return Ok(SourcePlan::Module(module));
|
||||
}
|
||||
// 一次词法分析获得原始字节 span,候选分段依赖 token 之间的实际换行而非直接按行切字符串。
|
||||
let tokens = frontend::lex_source(source)?;
|
||||
// 只保存已被 Aster 成功接受的交互根,失败候选不留下半棵 AST。
|
||||
let mut roots = Vec::new();
|
||||
// start 为当前待解析片段在原文件中的字节起点,仅在候选成功时前移。
|
||||
let mut start = 0;
|
||||
// 深度只是候选边界启发式;括号失配是否合法仍由 Aster 判定,不在宿主偷偷修正。
|
||||
let mut depth = 0_i64;
|
||||
for (index, token) in tokens.iter().enumerate() {
|
||||
// 追踪圆/花括号嵌套,括号内换行不能直接结束输入;最终语法是否合法仍交给 Aster。
|
||||
match token.kind {
|
||||
// token 已由词法器识别,字符串/注释里的括号不会当作结构括号改变深度。
|
||||
TokenKind::LeftParen | TokenKind::LeftBrace => depth += 1,
|
||||
TokenKind::RightParen | TokenKind::RightBrace => depth -= 1,
|
||||
// 其他 token 不改变边界嵌套,不能靠普通字符扫描替代此判断。
|
||||
_ => {}
|
||||
}
|
||||
// token 尾为原文本字节位置,用它取与下一 token 之间的空白/注释区域查换行。
|
||||
let end = token.span.end;
|
||||
// 末尾 token 总是尝试解析;非末尾要求顶层换行,且下一 token 不像成员访问、调用或算术续接。
|
||||
let boundary = tokens.get(index + 1).is_none_or(|next| {
|
||||
// 尚在括号内,或下一 token 明显续接上个表达式时,不尝试提前提交当前交互片段。
|
||||
depth == 0
|
||||
&& source.text()[end..next.span.start].contains(['\r', '\n'])
|
||||
&& !matches!(
|
||||
next.kind,
|
||||
TokenKind::Dot
|
||||
| TokenKind::LeftParen
|
||||
| TokenKind::Plus
|
||||
| TokenKind::Minus
|
||||
| TokenKind::Star
|
||||
| TokenKind::Slash
|
||||
)
|
||||
});
|
||||
if !boundary {
|
||||
// 保留 start,之后尝试更长的片段;不是丢弃当前 token 对应源码。
|
||||
continue;
|
||||
}
|
||||
// 当前片段从上一次成功边界 start 开始,保留期间的空白与注释;解析器看到的是片段局部字节位置。
|
||||
match frontend::parse_ast(&source.text()[start..end], ParseMode::Interactive) {
|
||||
Ok(mut root) => {
|
||||
// Interactive 模式的成功根必须为 Interactive;违反是前端接口不变量错误。
|
||||
let AstRoot::Interactive(input) = &mut root else {
|
||||
unreachable!("interactive mode");
|
||||
};
|
||||
// 成功后递归加回 start,把整个 AST 的局部 span 转成原文件位置,再推进下一段起点。
|
||||
shift_input(input, start);
|
||||
roots.push(root);
|
||||
start = end;
|
||||
}
|
||||
// 错误恰在片段末尾且还有 token 时,视为可能未完成的交互输入,保持 start 不动继续拼接。
|
||||
Err(diagnostic) if index + 1 < tokens.len() && diagnostic.span.start == end - start => {
|
||||
// 只有“诊断正好指向片段末尾”才暂缓,下一候选会连同当前片段一起再交 Aster 解析。
|
||||
}
|
||||
Err(mut diagnostic) => {
|
||||
// 其他语法错误立即恢复原始偏移,再用 SourceUnit 添加原文件来源与行列诊断。
|
||||
shift_span(&mut diagnostic.span, start);
|
||||
return Err(source.annotate(diagnostic).into());
|
||||
}
|
||||
}
|
||||
}
|
||||
// 没有接受任何片段时,再把完整输入交给前端校验;是否为空输入/注释及是否可接受,仍由前端定义。
|
||||
if roots.is_empty() {
|
||||
// 不自造宿主错误字符串;失败则保留前端诊断,成功也不把这次仅用于校验的根追加到 roots。
|
||||
frontend::parse_source_ast(source, ParseMode::Interactive)?;
|
||||
}
|
||||
Ok(SourcePlan::Script(roots))
|
||||
}
|
||||
|
||||
/// 下方所有 shift_* 调用的基本操作,给单个半开字节范围加偏移,不递归、不改变源码内容。
|
||||
fn shift_span(span: &mut Span, offset: usize) {
|
||||
// span 采用原文本字节偏移,start/end 同增 offset 保持长度;不是按字符数或行数偏移。
|
||||
span.start += offset;
|
||||
span.end += offset;
|
||||
}
|
||||
|
||||
/// parse 在接受一个 Interactive 根后调用,平移交互根范围,再把语句交给 shift_statement 递归。
|
||||
fn shift_input(input: &mut InteractiveInput, offset: usize) {
|
||||
shift_span(&mut input.span, offset);
|
||||
// 根范围之外,逐条语句递归处理所有内层节点,避免错误只在顶层位置正确。
|
||||
for statement in &mut input.statements {
|
||||
shift_statement(statement, offset);
|
||||
}
|
||||
}
|
||||
|
||||
/// shift_input/函数体/分支体的递归入口,按语句种类平移自己的范围和所有内嵌表达式/声明。
|
||||
fn shift_statement(statement: &mut Stmt, offset: usize) {
|
||||
shift_span(&mut statement.span, offset);
|
||||
match &mut statement.kind {
|
||||
StmtKind::If(branch) => {
|
||||
// If 节点、条件、then 块各有独立 span,平移外层 Stmt 不能自动更新它们。
|
||||
shift_span(&mut branch.span, offset);
|
||||
shift_expression(&mut branch.condition, offset);
|
||||
shift_span(&mut branch.body.span, offset);
|
||||
for s in &mut branch.body.statements {
|
||||
// then 内可能继续嵌套 if/while/声明,不能只调整第一层语句外框。
|
||||
shift_statement(s, offset);
|
||||
}
|
||||
if let Some(body) = &mut branch.otherwise {
|
||||
// else 可省略;存在时块范围和其中每条语句都使用同一个原片段偏移。
|
||||
shift_span(&mut body.span, offset);
|
||||
for s in &mut body.statements {
|
||||
shift_statement(s, offset);
|
||||
}
|
||||
}
|
||||
}
|
||||
StmtKind::While(loop_) => {
|
||||
// while 条件和循环体均可含更深的调用/控制流,沿各自 AST 子结构递归而非重新扫描文本。
|
||||
shift_span(&mut loop_.span, offset);
|
||||
shift_expression(&mut loop_.condition, offset);
|
||||
shift_span(&mut loop_.body.span, offset);
|
||||
for s in &mut loop_.body.statements {
|
||||
shift_statement(s, offset);
|
||||
}
|
||||
}
|
||||
StmtKind::Binding(binding) => {
|
||||
// 新绑定独立保存名字和右值范围,诊断未定义符号时需要内部表达式位置正确。
|
||||
shift_span(&mut binding.span, offset);
|
||||
shift_span(&mut binding.name.span, offset);
|
||||
shift_expression(&mut binding.value, offset);
|
||||
}
|
||||
StmtKind::Assignment(assignment) => {
|
||||
// 赋值不同于声明,但同样保留名字与右值两个来源范围,不能仅平移整个语句。
|
||||
shift_span(&mut assignment.span, offset);
|
||||
shift_span(&mut assignment.name.span, offset);
|
||||
shift_expression(&mut assignment.value, offset);
|
||||
}
|
||||
// 成员赋值同时包含目标对象表达式、成员名和右值,三部分都要恢复原始位置。
|
||||
StmtKind::MemberAssignment(assignment) => {
|
||||
shift_span(&mut assignment.span, offset);
|
||||
shift_span(&mut assignment.name.span, offset);
|
||||
shift_expression(&mut assignment.object, offset);
|
||||
shift_expression(&mut assignment.value, offset);
|
||||
}
|
||||
StmtKind::Return(returned) => {
|
||||
// return 自身 span 必须平移;无返回表达式的 Unit 返回不能访问不存在的 value。
|
||||
shift_span(&mut returned.span, offset);
|
||||
if let Some(expression) = &mut returned.value {
|
||||
// 返回值可以是任意复合调用/算术表达式,继续下钻到全部名称和实参。
|
||||
shift_expression(expression, offset);
|
||||
}
|
||||
}
|
||||
// 表达式语句复用完整表达式递归,避免调用参数中的错误仍显示片段局部行列。
|
||||
StmtKind::Expression(expression) => shift_expression(expression, offset),
|
||||
// 顶层/局部声明转交类与函数专用入口,处理参数、类型名及函数体。
|
||||
StmtKind::Declaration(declaration) => shift_declaration(declaration, offset),
|
||||
}
|
||||
}
|
||||
|
||||
/// shift_statement 在声明语句中调用,平移 Decl 外层,再区分函数定义与类定义的内部位置。
|
||||
fn shift_declaration(declaration: &mut Decl, offset: usize) {
|
||||
shift_span(&mut declaration.span, offset);
|
||||
match &mut declaration.kind {
|
||||
// 普通函数和类方法使用相同函数结构,统一由 shift_function 平移签名和函数体。
|
||||
DeclKind::Function(function) => shift_function(function, offset),
|
||||
// 类的名称、基类、字段类型和方法均保存独立 span,不能仅移动声明外层范围。
|
||||
DeclKind::Class(class) => {
|
||||
shift_span(&mut class.span, offset);
|
||||
shift_span(&mut class.name.span, offset);
|
||||
if let Some(base) = &mut class.base {
|
||||
// 无显式基类时不新增默认基类 span,保留前端原始 AST 的可选结构。
|
||||
shift_span(&mut base.span, offset);
|
||||
}
|
||||
for field in &mut class.fields {
|
||||
// 字段节点整体、字段名、类型名分别保存位置,错误类型注解必须指回原文件。
|
||||
shift_span(&mut field.span, offset);
|
||||
shift_span(&mut field.name.span, offset);
|
||||
shift_span(&mut field.type_name.span, offset);
|
||||
}
|
||||
for method in &mut class.methods {
|
||||
// 方法体可能包含更多声明,沿同一套递归入口继续处理。
|
||||
shift_function(method, offset);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// shift_declaration 调用,平移函数名、参数/返回注解和函数体,供编译器类型错误使用原输入坐标。
|
||||
fn shift_function(function: &mut frontend::ast::Function, offset: usize) {
|
||||
shift_span(&mut function.span, offset);
|
||||
shift_span(&mut function.name.span, offset);
|
||||
shift_span(&mut function.return_type.span, offset);
|
||||
// 参数自身、名称、类型各有范围;函数返回类型和函数体范围也独立移动。
|
||||
for parameter in &mut function.parameters {
|
||||
shift_span(&mut parameter.span, offset);
|
||||
shift_span(&mut parameter.name.span, offset);
|
||||
shift_span(&mut parameter.type_name.span, offset);
|
||||
}
|
||||
shift_span(&mut function.body.span, offset);
|
||||
for statement in &mut function.body.statements {
|
||||
// 函数体内每条语句继续按 kind 递归,不能用整体函数范围覆盖内部诊断。
|
||||
shift_statement(statement, offset);
|
||||
}
|
||||
}
|
||||
|
||||
/// 语句/函数递归助手调用,平移表达式与名称成员的范围;语义值和运算符本身保持不变。
|
||||
fn shift_expression(expression: &mut Expr, offset: usize) {
|
||||
shift_span(&mut expression.span, offset);
|
||||
match &mut expression.kind {
|
||||
// 这些叶节点只用表达式外层 span;Symbol/Member 的名称还保存额外 span,需继续调整。
|
||||
ExprKind::Name(_) | ExprKind::Number(_) | ExprKind::String(_) => {}
|
||||
ExprKind::Symbol(name) => shift_span(&mut name.span, offset),
|
||||
ExprKind::Unary { operand, .. } | ExprKind::Await(operand) => {
|
||||
// unary 与 await 都只有一个子表达式,操作符来源已在外层表达式 span 覆盖。
|
||||
shift_expression(operand, offset)
|
||||
}
|
||||
ExprKind::Binary { left, right, .. } => {
|
||||
// 两侧都可能含复合表达式,不能只调整最终报错概率更高的右侧。
|
||||
shift_expression(left, offset);
|
||||
shift_expression(right, offset);
|
||||
}
|
||||
ExprKind::Member { object, name } => {
|
||||
// object 可能是调用返回值,name 则是独立标识符,分别调整两类来源。
|
||||
shift_expression(object, offset);
|
||||
shift_span(&mut name.span, offset);
|
||||
}
|
||||
// 调用目标可继续是成员/调用等复合表达式;逐个递归实参而非只改整个 Call 的范围。
|
||||
ExprKind::Call { callee, arguments } => {
|
||||
shift_expression(callee, offset);
|
||||
for argument in arguments {
|
||||
// 保持实参顺序和值不变,只平移每个实参树内部保存的字节位置。
|
||||
shift_expression(argument, offset);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,411 +0,0 @@
|
||||
//! 后台文件/网络 provider。线程池只携带纯数据、取消控制与弱 Task 身份,不持有 VM。
|
||||
//! Lease 由托管任务拥有,释放会撤销交付资格并取消可取消的后台工作;已经完成的结果还要由 VM worker 检查归属后才能交付。
|
||||
//! 并发、队列、读取字节数、超时和 URL 协议均有边界,避免 provider 绕过运行时资源限制。
|
||||
//!
|
||||
//! runtime::tasks 为 readText/fetchText 创建 Task 时调用 Provider::submit,并把返回 Lease 放进 Task payload。
|
||||
//! Scheduler 轮询 Provider::take_ready 后在 owning VM 中核验弱身份、owner/key 与取消状态,再调用源回调。
|
||||
//! 所有 Provider 共用一个全进程有界线程池;每个运行时仍有自己的结果邮箱与租约额度,不互读 Task 堆。
|
||||
use endor_core::{VmError, WeakObjectRef};
|
||||
use std::{
|
||||
collections::HashMap,
|
||||
fs::File,
|
||||
io::{Read, Write},
|
||||
process::{Child, Command, Stdio},
|
||||
sync::{
|
||||
Arc, Mutex, OnceLock,
|
||||
atomic::{AtomicBool, AtomicUsize, Ordering},
|
||||
mpsc::{SyncSender, sync_channel},
|
||||
},
|
||||
thread,
|
||||
time::Duration,
|
||||
};
|
||||
|
||||
// 文件与 HTTP 返回文本最多 1 MiB,最终必须为有效 UTF-8;长度按字节计算。
|
||||
const MAX_TEXT: usize = 1024 * 1024;
|
||||
// 每个运行时的租约额度,独立于全进程 4 个执行线程和 64 项工作队列。
|
||||
const MAX_ACTIVE: usize = 16;
|
||||
// 全进程实际执行 OS I/O 的线程数;排队不等于已占一个执行线程。
|
||||
const WORKERS: usize = 4;
|
||||
// 工作队列全局上限,try_send 失败直接反馈给提交方,不让 VM 阻塞等空位。
|
||||
const QUEUE: usize = 64;
|
||||
// 成功/失败都只传字符串;不能把 VmError 内部可能关联的托管值或 VM 句柄送入后台线程。
|
||||
type Completion = Result<String, String>;
|
||||
|
||||
#[derive(Debug, Default)]
|
||||
/// provider 共享的就绪结果与并发计数;内容只有纯数据和弱任务身份。
|
||||
struct Shared {
|
||||
// worker 写入、take_ready 排空,Lease::drop 也会移除本任务的晚到/未取结果。
|
||||
ready: Mutex<HashMap<WeakObjectRef, Completion>>,
|
||||
// 统计当前活租约而非正在执行的 OS 操作;完成结果被取走前,租约仍可能占用名额。
|
||||
active: AtomicUsize,
|
||||
}
|
||||
#[derive(Clone, Debug, Default)]
|
||||
/// 某个运行时拥有的后台 provider 能力,负责提交和取走完成结果。
|
||||
pub struct Provider {
|
||||
// Arc 可供后台 Job 访问邮箱,不代表 Job 拥有 Task 或能延长交付租约。
|
||||
shared: Arc<Shared>,
|
||||
}
|
||||
#[derive(Debug, Default)]
|
||||
/// 后台工作取消标记与可取消子进程,不拥有托管 VM。
|
||||
struct Control {
|
||||
// Release/Acquire 传播取消资格;最终写邮箱时还需在 ready 锁内再次检查。
|
||||
cancelled: AtomicBool,
|
||||
process: Mutex<Option<Child>>,
|
||||
}
|
||||
impl Control {
|
||||
/// Lease 析构调用,可在 VM/租约线程执行;只撤资格/kill,不在调用线程 wait 进程退出。
|
||||
fn cancel(&self) {
|
||||
// 先撤销结果交付资格,再尝试终止当前子进程;文件读取无法用此标记中断,只能丢弃晚到结果。
|
||||
self.cancelled.store(true, Ordering::Release);
|
||||
if let Ok(mut process) = self.process.lock()
|
||||
&& let Some(child) = process.as_mut()
|
||||
{
|
||||
// Reaping belongs to the provider worker, never the VM thread.
|
||||
// VM/租约线程这里只 kill,不 wait;子进程回收由持有 Reaper 的 I/O worker 完成,避免阻塞 VM。
|
||||
let _ = child.kill();
|
||||
}
|
||||
}
|
||||
}
|
||||
#[derive(Debug)]
|
||||
/// 后台工作种类及其纯文本参数,源调用的类型检查在提交前完成。
|
||||
pub enum Request {
|
||||
// 本地路径已在任务创建时做类型/长度校验,worker 再检查实际文件类型和大小。
|
||||
ReadText(String),
|
||||
// URL 会由 fetch_text 再验证 HTTP(S)/authority,传输不用 shell 解释。
|
||||
FetchText(String),
|
||||
}
|
||||
#[derive(Debug)]
|
||||
/// 仅托管 Task 拥有的交付租约;释放它会取消后台资格并清理晚到结果。
|
||||
pub struct Lease {
|
||||
// 归还名额与移除结果所需共享状态;不持有任务本体,避免后台根反向保活源程序。
|
||||
shared: Arc<Shared>,
|
||||
// 带代际的弱身份用于邮箱键,Task 死亡后不能让旧结果命中复用槽位的新任务。
|
||||
task: WeakObjectRef,
|
||||
// 取消后台进程/晚到交付的纯原生控制对象,后台 Job 只共享它而不共享 Lease。
|
||||
control: Arc<Control>,
|
||||
}
|
||||
impl Drop for Lease {
|
||||
/// 最后一个 Arc<Lease> 释放时撤销交付资格、删除待交付结果并归还一次并发额度;后台 Job 不延长租约。
|
||||
fn drop(&mut self) {
|
||||
// 租约释放立即取消交付资格;后台 OS 读取即使稍后结束,也不能再次唤醒旧 Task。
|
||||
self.control.cancel();
|
||||
if let Ok(mut ready) = self.shared.ready.lock() {
|
||||
// 删除已到邮箱的结果;worker 同锁复查 cancelled,所以取消之后也不能重新留下结果。
|
||||
ready.remove(&self.task);
|
||||
}
|
||||
// Lease 包在 Arc 中,只有最后一个拥有者释放才析构并归还一次额度;Job 不持有 Lease。
|
||||
self.shared.active.fetch_sub(1, Ordering::AcqRel);
|
||||
}
|
||||
}
|
||||
/// 线程池队列中的纯数据工作,关联弱任务身份、控制和共享完成表。
|
||||
struct Job {
|
||||
// 操作种类及参数只含拥有字符串,不借用 VM 对象属性或源参数切片。
|
||||
request: Request,
|
||||
// 只用于交付结果地址,后台从不尝试升级弱引用。
|
||||
task: WeakObjectRef,
|
||||
// 共享取消状态/进程槽,让租约销毁可终止传输;Job 不持 Lease,因此不阻止取消。
|
||||
control: Arc<Control>,
|
||||
// 结果写入对应 Provider 的 mailbox,不把不同运行时结果混入一个全局表。
|
||||
shared: Arc<Shared>,
|
||||
}
|
||||
impl Provider {
|
||||
/// tasks 的 I/O 创建路径调用,原子预占额度、建立 RAII Lease 并非阻塞入队,返回交付资格而非执行结果。
|
||||
pub fn submit(
|
||||
&self,
|
||||
task: WeakObjectRef,
|
||||
request: Request,
|
||||
replacing: bool,
|
||||
) -> Result<Arc<Lease>, VmError> {
|
||||
// 原子更新同时完成检查和预占,防止并发提交都观察到剩余名额而超配。
|
||||
// replacing 允许替换期间临时多一个租约,旧任务取消后回到正常上限。
|
||||
self.shared
|
||||
.active
|
||||
.fetch_update(Ordering::AcqRel, Ordering::Acquire, |active| {
|
||||
// replacing 只放宽一次替换的瞬时名额,不为普通提交永久提升每运行时上限。
|
||||
(active < MAX_ACTIVE + usize::from(replacing)).then_some(active + 1)
|
||||
})
|
||||
.map_err(|_| VmError::ExecutionLimit("16 I/O tasks per runtime"))?;
|
||||
// 预占后立即建立 RAII 租约;线程池不可用或队列发送失败时,局部 lease 析构会归还名额。
|
||||
let lease = Arc::new(Lease {
|
||||
shared: self.shared.clone(),
|
||||
task,
|
||||
control: Arc::new(Control::default()),
|
||||
});
|
||||
// 池初始化也可能失败;lease 已建立,任何后续 ? 都会归还预占额度。
|
||||
let sender = pool().map_err(|_| VmError::InvalidArgument("I/O provider unavailable"))?;
|
||||
// 非阻塞入队,不让调用 VM 等待后台吞吐;Job 只带参数、弱任务身份和原生取消/结果状态。
|
||||
sender
|
||||
.try_send(Job {
|
||||
request,
|
||||
task,
|
||||
control: lease.control.clone(),
|
||||
shared: self.shared.clone(),
|
||||
})
|
||||
.map_err(|_| VmError::ExecutionLimit("I/O provider queue full or unavailable"))?;
|
||||
Ok(lease)
|
||||
}
|
||||
/// Scheduler::poll 在 VM worker 调用,排空此 Provider 的已就绪纯数据,不在邮箱锁中执行源回调。
|
||||
// 一次 drain 所有已就绪结果;移走纯数据不代表任务仍可交付,VM worker 还需检查弱身份和归属。
|
||||
pub fn take_ready(&self) -> Result<Vec<(WeakObjectRef, Completion)>, VmError> {
|
||||
Ok(self
|
||||
.shared
|
||||
.ready
|
||||
.lock()
|
||||
.map_err(|_| VmError::InvalidArgument("I/O mailbox poisoned"))?
|
||||
.drain()
|
||||
.collect())
|
||||
}
|
||||
}
|
||||
/// Provider::submit 调用,懒初始化全进程线程池;返回借用的 SyncSender,不为每个 VM 新建 I/O 线程。
|
||||
fn pool() -> Result<&'static SyncSender<Job>, &'static str> {
|
||||
// 全进程只初始化一次,初始化失败也会记住失败结果;后续 submit 返回 unavailable,不反复创建线程。
|
||||
static POOL: OnceLock<Result<SyncSender<Job>, String>> = OnceLock::new();
|
||||
POOL.get_or_init(|| {
|
||||
// 队列只承载 Job;容量限制排队任务,不代替 Provider 自己的 MAX_ACTIVE 租约预算。
|
||||
let (sender, receiver) = sync_channel::<Job>(QUEUE);
|
||||
// std Receiver 不可 Clone,短锁共享接收端;拿到一个 Job 后放锁再并行执行 I/O。
|
||||
let receiver = Arc::new(Mutex::new(receiver));
|
||||
for index in 0..WORKERS {
|
||||
// 每线程持接收端 Arc,不持任何 Provider/Task 的租约,空闲时阻塞 recv 而非轮询。
|
||||
let receiver = receiver.clone();
|
||||
thread::Builder::new()
|
||||
.name(format!("tessera-io-{index}"))
|
||||
.spawn(move || {
|
||||
loop {
|
||||
// std mpsc Receiver 通过 Mutex 共享;锁只覆盖取任务,实际 I/O 在离开该 match 后并行执行。
|
||||
let job = match receiver.lock() {
|
||||
Ok(receiver) => receiver.recv(),
|
||||
// 接收锁损坏时终止该线程,不在不可靠队列状态上继续读任务。
|
||||
Err(_) => break,
|
||||
};
|
||||
let Ok(job) = job else {
|
||||
// 所有 sender 已断开就退出;这不是一个可重试的临时“队列为空”。
|
||||
break;
|
||||
};
|
||||
// 执行前先跳过已取消队列项,避免启动无用文件读取或 curl。
|
||||
if job.control.cancelled.load(Ordering::Acquire) {
|
||||
continue;
|
||||
}
|
||||
// 只进行原生文件/HTTP 操作,失败也编码成纯文本 Completion,留给 VM 线程交付。
|
||||
let result = match &job.request {
|
||||
Request::ReadText(path) => read_text(path),
|
||||
Request::FetchText(url) => fetch_text(url, &job.control),
|
||||
};
|
||||
// 持有 ready 锁后再次检查取消,与 Lease::drop 的取消/移除配合,防止取消后重新留下晚到结果。
|
||||
if let Ok(mut ready) = job.shared.ready.lock()
|
||||
&& !job.control.cancelled.load(Ordering::Acquire)
|
||||
{
|
||||
// 与 Lease::drop 用同一 ready 锁封住取消/插入竞争,晚到结果不能重新激活旧 Task。
|
||||
ready.insert(job.task, result);
|
||||
}
|
||||
}
|
||||
})
|
||||
.map_err(|error| error.to_string())?;
|
||||
}
|
||||
Ok(sender)
|
||||
})
|
||||
.as_ref()
|
||||
.map_err(|_| "I/O provider unavailable")
|
||||
}
|
||||
/// pool 的 ReadText 分支在后台调用,返回受字节预算限制的 UTF-8 文本或可交付错误字符串。
|
||||
fn read_text(path: &str) -> Completion {
|
||||
// 先按路径检查普通文件和已知长度,及早拒绝目录/超大源;实际打开后还会复核文件类型。
|
||||
let metadata = std::fs::metadata(path).map_err(|error| error.to_string())?;
|
||||
if !metadata.is_file() {
|
||||
return Err("text source must be a regular file".into());
|
||||
}
|
||||
if metadata.len() > MAX_TEXT as u64 {
|
||||
// 提交线程已校验路径字符串,这里依据实际文件长度提前拒绝,避免明显超限请求进入读取阶段。
|
||||
return Err("text source exceeds 1 MiB".into());
|
||||
}
|
||||
// 路径检查与打开之间可能变化,所以打开后再次检查句柄实际指向的对象类型。
|
||||
let file = File::open(path).map_err(|error| error.to_string())?;
|
||||
if !file
|
||||
.metadata()
|
||||
.map_err(|error| error.to_string())?
|
||||
.is_file()
|
||||
{
|
||||
return Err("text source must be a regular file".into());
|
||||
}
|
||||
// 原始字节最后才严格转 UTF-8,不用有损替换悄悄改写用户文件内容。
|
||||
let mut bytes = Vec::new();
|
||||
// 再用流读取硬上限检测增长中的文件:多读一个字节即可判断超限,不能只依赖之前 metadata 长度。
|
||||
file.take(MAX_TEXT as u64 + 1)
|
||||
.read_to_end(&mut bytes)
|
||||
.map_err(|error| error.to_string())?;
|
||||
if bytes.len() > MAX_TEXT {
|
||||
// metadata 后文件仍可能增长,因此按实际读到的字节数再核验;多读的那个探测字节不会作为正文交付。
|
||||
return Err("text source exceeds 1 MiB".into());
|
||||
}
|
||||
String::from_utf8(bytes).map_err(|_| "text source must be UTF-8".into())
|
||||
}
|
||||
|
||||
/// tasks 创建 fetchText 与 fetch_text 真正传输前都会调用,拒绝错误协议、过长 URL、控制字符和 userinfo。
|
||||
/// 这是受限文本 GET 接口的基本格式检查,不负责完整 URL 规范化,也不声明网络地址访问授权。
|
||||
pub fn valid_url(url: &str) -> bool {
|
||||
// 控制字符必须在写 curl config 前拒绝,否则换行等可能破坏单个 url 配置项边界。
|
||||
if url.len() > 8192 || url.chars().any(char::is_control) {
|
||||
return false;
|
||||
}
|
||||
let Some((scheme, rest)) = url.split_once("://") else {
|
||||
// 只接受有显式 scheme 的 URL,不让 curl 猜协议或把路径当作另一类资源地址。
|
||||
return false;
|
||||
};
|
||||
if !scheme.eq_ignore_ascii_case("http") && !scheme.eq_ignore_ascii_case("https") {
|
||||
// scheme 不区分大小写,但必须是明确 HTTP(S);拒绝 file 等其他 curl 可处理协议,不依赖调用方只传网页地址。
|
||||
return false;
|
||||
}
|
||||
// 仅检查协议与 authority 基本约束;@ 禁止 userinfo 凭据,空白禁止模糊主机部分。
|
||||
// 这不是完整 URL 解析器,具体 HTTP 解析仍由 curl 负责。
|
||||
let authority = rest.split(['/', '?', '#']).next().unwrap_or("");
|
||||
!authority.is_empty() && !authority.contains('@') && !authority.chars().any(char::is_whitespace)
|
||||
}
|
||||
|
||||
/// fetch_text 仅在 I/O worker 上创建的清理守卫;任何提前返回都取走、kill/wait 尚未回收的子进程。
|
||||
struct Reaper<'a>(&'a Control);
|
||||
impl Drop for Reaper<'_> {
|
||||
/// 取走残留 curl 子进程后尝试 kill/wait,保证失败或取消路径也回收进程,且不持控制锁等待。
|
||||
fn drop(&mut self) {
|
||||
// 从控制槽取出子进程后释放锁,再 kill/wait;只有实际留下的进程才需要回收。
|
||||
let child = self.0.process.lock().ok().and_then(|mut slot| slot.take());
|
||||
if let Some(mut child) = child {
|
||||
// 两项清理都尽力尝试,kill 的错误不跳过 wait;进程可能已经退出,回收仍由这个后台 worker 完成。
|
||||
let _ = child.kill();
|
||||
let _ = child.wait();
|
||||
}
|
||||
}
|
||||
}
|
||||
/// pool 的 FetchText 分支调用,用系统 curl 做有界 HTTP GET;所有等待与进程回收都发生在后台线程。
|
||||
fn fetch_text(url: &str, control: &Control) -> Completion {
|
||||
if !valid_url(url) {
|
||||
return Err("invalid HTTP(S) URL".into());
|
||||
}
|
||||
#[cfg(unix)]
|
||||
// Unix 固定系统路径,不从用户 PATH 选择任意同名可执行文件。
|
||||
let executable = "/usr/bin/curl";
|
||||
#[cfg(not(unix))]
|
||||
// 非 Unix 使用系统环境可解析的 curl.exe,找不到时反馈明确的传输不可用错误。
|
||||
let executable = "curl.exe";
|
||||
// 参数数组直接交给进程 API,URL 另外经 stdin 配置传入,全程不经 shell 拼接。
|
||||
let mut child = Command::new(executable)
|
||||
// --disable 放首项关闭 curlrc,--globoff 禁用 URL 展开,首次请求与重定向均限制 HTTP(S)。
|
||||
// 限制重定向数、连接/总超时和下载大小;--compressed 后仍会用下面字节读取上限限制解压文本。
|
||||
.args([
|
||||
"--disable",
|
||||
"--silent",
|
||||
"--show-error",
|
||||
"--globoff",
|
||||
"--location",
|
||||
"--max-redirs",
|
||||
"5",
|
||||
"--proto",
|
||||
"=http,https",
|
||||
"--proto-redir",
|
||||
"=http,https",
|
||||
"--max-time",
|
||||
"30",
|
||||
"--connect-timeout",
|
||||
"10",
|
||||
"--max-filesize",
|
||||
"1048576",
|
||||
"--compressed",
|
||||
"--fail",
|
||||
"--write-out",
|
||||
"\n%{http_code}",
|
||||
"--config",
|
||||
"-",
|
||||
])
|
||||
.stdin(Stdio::piped())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::null())
|
||||
.spawn()
|
||||
.map_err(|_| "HTTP transport unavailable: system curl is required".to_owned())?;
|
||||
// 取走管道后把 Child 放入共享 Control,取消线程可随时 kill;Reaper 覆盖其后的所有提前返回。
|
||||
// 管道配置是上方 spawn 的内部前提,take 后分别归配置写入和正文读取负责。
|
||||
let mut input = child.stdin.take().expect("piped stdin");
|
||||
// 取走 stdout 后 Child 仍可放入共享进程槽供取消线程 kill。
|
||||
let output = child.stdout.take().expect("piped stdout");
|
||||
match control.process.lock() {
|
||||
Ok(mut slot) => *slot = Some(child),
|
||||
Err(_) => {
|
||||
// 尚未安装 Reaper 且不能存入共享槽,当前线程必须亲自 kill/wait 清理已启动子进程。
|
||||
let _ = child.kill();
|
||||
let _ = child.wait();
|
||||
return Err("HTTP process lock poisoned".into());
|
||||
}
|
||||
}
|
||||
// 从这里起即使写配置/读正文/解析状态失败,也会通过 Drop 回收进程而不留下僵尸。
|
||||
let _reaper = Reaper(control);
|
||||
if control.cancelled.load(Ordering::Acquire) {
|
||||
return Err("request cancelled".into());
|
||||
}
|
||||
// URL 经 curl 配置的引号/反斜杠转义后走 stdin,避免出现在进程参数;这里不经过 shell。
|
||||
let escaped = url.replace('\\', "\\\\").replace('"', "\\\"");
|
||||
writeln!(input, "url = \"{escaped}\"").map_err(|_| "HTTP transport input failed".to_owned())?;
|
||||
// 关闭 stdin 表示配置结束,否则 curl 可能继续等待输入,无法开始/完成请求。
|
||||
drop(input);
|
||||
// stdout 同时含正文与 curl --write-out 状态尾,预算须为尾部保留四字节。
|
||||
let mut bytes = Vec::new();
|
||||
output
|
||||
// 预留结尾换行和三位状态码共 4 字节,再额外读 1 字节探测正文超限。
|
||||
.take(MAX_TEXT as u64 + 5)
|
||||
.read_to_end(&mut bytes)
|
||||
.map_err(|_| "HTTP response read failed".to_owned())?;
|
||||
if bytes.len() > MAX_TEXT + 4 {
|
||||
// 四字节属于 curl 追加的换行/状态码尾部,超过正文预算加尾部即拒绝;Reaper 随返回回收仍可能运行的 curl。
|
||||
return Err("HTTP text exceeds 1 MiB".into());
|
||||
}
|
||||
// 读完输出后用 try_wait 检查退出;等待间隔先释放 process 锁,让其他线程仍可取消进程。
|
||||
let status = loop {
|
||||
// 短暂持锁查询 child 状态;睡眠前释放槽锁,让 Lease::drop 仍可及时 kill。
|
||||
let mut slot = control
|
||||
.process
|
||||
.lock()
|
||||
.map_err(|_| "HTTP process lock poisoned".to_owned())?;
|
||||
// 槽内 Child 在本请求结束前应存在;缺项是状态错误,不继续对另一进程等待。
|
||||
let child = slot.as_mut().ok_or("HTTP process missing")?;
|
||||
if let Some(status) = child
|
||||
.try_wait()
|
||||
.map_err(|_| "HTTP transport wait failed".to_owned())?
|
||||
{
|
||||
// try_wait 已回收退出状态,移除 Child 后 Reaper 析构不会再次 kill/wait 同一个进程。
|
||||
slot.take();
|
||||
break status;
|
||||
}
|
||||
drop(slot);
|
||||
thread::sleep(Duration::from_millis(2));
|
||||
};
|
||||
if control.cancelled.load(Ordering::Acquire) {
|
||||
// 完成传输并不自动取得交付资格,取消优先于刚读到的正常 HTTP 返回值。
|
||||
return Err("request cancelled".into());
|
||||
}
|
||||
// --write-out 的末尾四字节应是换行加三位状态码;checked_sub 处理空/短输出,不直接倒数切片。
|
||||
let code = bytes
|
||||
.len()
|
||||
.checked_sub(4)
|
||||
.and_then(|offset| (bytes[offset] == b'\n').then_some(&bytes[offset + 1..]))
|
||||
.and_then(|digits| std::str::from_utf8(digits).ok())
|
||||
.and_then(|digits| digits.parse::<u16>().ok());
|
||||
// 已知 HTTP 3xx/4xx/5xx 优先以 HTTP 错误报告,其他 curl 非零状态再映射为超时、大小或传输失败。
|
||||
if let Some(code) = code
|
||||
&& code >= 300
|
||||
{
|
||||
return Err(format!("HTTP {code}"));
|
||||
}
|
||||
if !status.success() {
|
||||
// 区分 curl 的超时/大小错误,其余保留退出码供诊断;信号终止没有普通退出码。
|
||||
return Err(match status.code() {
|
||||
Some(28) => "HTTP request timed out".into(),
|
||||
Some(63) => "HTTP text exceeds 1 MiB".into(),
|
||||
Some(code) => format!("HTTP transport failed (curl {code})"),
|
||||
None => "HTTP transport terminated".into(),
|
||||
});
|
||||
}
|
||||
if !code.is_some_and(|code| (200..300).contains(&code)) {
|
||||
// 即使 curl 成功退出,也须有完整且为 2xx 的状态尾;没有状态不能把截断/异常输出当作成功正文。
|
||||
return Err("HTTP response status unavailable".into());
|
||||
}
|
||||
// 确认 2xx 与成功退出后才剥去协议附加状态尾部,再严格解码 UTF-8 正文。
|
||||
bytes.truncate(bytes.len() - 4);
|
||||
String::from_utf8(bytes).map_err(|_| "HTTP text must be UTF-8".into())
|
||||
}
|
||||
+4
-7
@@ -1,22 +1,19 @@
|
||||
//! 运行时模块入口。VM 生命周期、API、源程序组织、事件与异步任务在这里组合。
|
||||
//! main 调用 api::start 建立服务;worker 通过 endor_host 操作所属 VM,events 客户端将原生输入排队交付。
|
||||
//! 任务后台只完成纯数据 I/O,结果是否仍可交付以及如何回到源回调,由串行运行时检查和推进。
|
||||
//! 通用源码/编译、持久输入执行、VM 根清理、任务、I/O 和驱动实现逐步移入 Nexus;这里保留应用组合与兼容适配路径。
|
||||
//!
|
||||
// 目录确定模块归属;main 中的 crate 根别名保持内部调用路径稳定。
|
||||
/// 提供 HTTP 路由、有界请求队列与串行 worker,协调候选 VM 和已发布 namespace。
|
||||
pub(crate) mod api;
|
||||
/// 拥有真实 Aster VM 会话,组合源执行、增量刷新、事件、任务和资源清理。
|
||||
/// 通过 Nexus VmSession 持有真实 Aster VM,适配 UI 源执行、增量刷新、事件、任务和资源清理。
|
||||
pub(crate) mod endor_host;
|
||||
/// 识别并组织 Endor 源输入,保留原始诊断位置,支持脚本和兼容入口形式。
|
||||
pub(crate) mod endor_script;
|
||||
/// 在 VM 中执行捕获/目标/冒泡路由,处理监听器断开、传播停止与事件结果。
|
||||
/// 监听器错误会中断序列;末尾 Finish 是正常路径步骤,不是确保异常后仍运行的 finally。
|
||||
pub(crate) mod event_dispatch;
|
||||
/// 定义原生输入信封与有界客户端,将窗口输入送往运行时而不跨线程调用源函数。
|
||||
pub(crate) mod events;
|
||||
/// 执行后台文件/HTTP 文本读取,使用租约拒绝取消后的交付;后台不操作 VM 对象。
|
||||
pub(crate) mod io_tasks;
|
||||
/// 维护 owner/key 任务身份、定时器、协作执行与 await 依赖,统一处理替换和取消。
|
||||
/// 为 Nexus 任务引擎适配 UI owner 作用域、窗口页面资格及 Task 类型,保留原安装/取消入口。
|
||||
pub(crate) mod tasks;
|
||||
/// 封装可恢复 VM 工作的推进次序,使源布局/绘制在预算内保留同一续体而不重放。
|
||||
/// 为 Nexus 的调用序列驱动适配桌面 Function 类型,使布局/绘制保留同一续体而不重放。
|
||||
pub(crate) mod vm_sequence;
|
||||
|
||||
+41
-1185
File diff suppressed because it is too large
Load Diff
+32
-211
@@ -1,93 +1,42 @@
|
||||
//! 构造共享 VM 调用序列与同帧循环驱动的字节码。
|
||||
//! 用托管函数串联步骤,避免为每个布局节点反复创建独立解释器调用;重复驱动会保留同一个执行帧和预算域。
|
||||
//!
|
||||
//! mount::synchronize 与 event_dispatch::dispatch 用 build 串起生命周期/事件回调。
|
||||
//! source_layout/source_paint 用 repeat_call 循环推进出现位置,并用 collect_and_continue 收集单次源调用结果。
|
||||
//! 本模块只生成驱动字节码和托管函数,不在 Rust 中自行解释语句,也不替调用方重置 VM 预算。
|
||||
//! 原生调用返回 Invoke 后,VM 在既有帧循环中执行驱动,因此可挂起工作仍有明确的 owning VM。
|
||||
//! build 串联的是普通调用序列,任一步报错便中断后续步骤;末项不是 finally,错误时临时根/检查点仍须由所属工作收尾路径释放。
|
||||
use endor_core::{
|
||||
CodeLayout, EndorCode, EndorCodeObject, Instruction, NativeContext, ObjectRef, Opcode, Value,
|
||||
VmError,
|
||||
};
|
||||
//! Tessera 的 Nexus 驱动适配:保留原调用签名,桌面 Function 绑定仍由 UI bridge 执行。
|
||||
use endor_core::{NativeContext, ObjectRef, Value, VmError};
|
||||
|
||||
/// 将零参数调用列表编成一个托管驱动,按输入顺序执行,返回最后一次调用的值。
|
||||
/// 空列表返回 Nil。所有调用都在调用者的 VM 预算内运行,避免宿主逐个调用时重置预算。
|
||||
/// name 用于诊断位置;desktop 用来给生成函数挂接桌面 Function 类型。
|
||||
/// 调用者是 Mount 生命周期同步和事件路由;返回值是驱动函数身份,不是已经执行完的最后结果。
|
||||
/// 只在同步驱动构造期间借用 desktop,实际生成函数由其名义类型边保活领域定义。
|
||||
struct DesktopFunctions(ObjectRef);
|
||||
impl nexus::vm_sequence::FunctionHost for DesktopFunctions {
|
||||
/// Nexus 在驱动创建后调用,保持原先类型附着和错误传播顺序。
|
||||
fn attach_function(
|
||||
&self,
|
||||
cx: &mut NativeContext<'_>,
|
||||
function: ObjectRef,
|
||||
) -> Result<(), VmError> {
|
||||
crate::ui_bridge::attach_desktop_type(cx, function, "Function", self.0)
|
||||
}
|
||||
/// 保持既有 Tessera 原生驱动回溯标签,移动实现不改变诊断来源。
|
||||
fn source_name(&self) -> &'static str {
|
||||
"<tessera>"
|
||||
}
|
||||
}
|
||||
|
||||
/// Mount/事件适配调用;通用序列指令及根关系由 Nexus 生成,不重置 VM 执行预算。
|
||||
pub fn build(
|
||||
cx: &mut NativeContext<'_>,
|
||||
calls: Vec<ObjectRef>,
|
||||
name: &'static str,
|
||||
desktop: ObjectRef,
|
||||
) -> Result<ObjectRef, VmError> {
|
||||
// 每个函数放入常量池。LoadConst/PushNull/Call 组成零参数调用,
|
||||
// 中间结果由 PopTop 丢弃;最后结果留在栈顶交给 ReturnValue。
|
||||
// 每个中间调用至多四条指令,额外空间覆盖空序列和 ReturnValue;只是预留容量,不是指令预算。
|
||||
let mut instructions = Vec::with_capacity(calls.len() * 4 + 2);
|
||||
// 常量池强持有每个 callable,驱动存活期间不依赖调用方的 Rust Vec 保活。
|
||||
let mut constants: Vec<Value> = calls.into_iter().map(Value::Object).collect();
|
||||
for index in 0..constants.len() {
|
||||
// LoadConst 放函数,PushNull 建立 VM Call 所需前缀,Call 0 执行无显式实参的回调。
|
||||
instructions.push(Instruction::new(Opcode::LoadConst, index as u32));
|
||||
instructions.push(Instruction::simple(Opcode::PushNull));
|
||||
instructions.push(Instruction::new(Opcode::Call, 0));
|
||||
if index + 1 != constants.len() {
|
||||
// 只丢中间结果,避免把最后一个结果也弹掉而让 ReturnValue 面对空栈。
|
||||
instructions.push(Instruction::simple(Opcode::PopTop));
|
||||
}
|
||||
}
|
||||
// 没有调用时也必须给 ReturnValue 提供合法栈顶,不能返回一个空栈。
|
||||
if constants.is_empty() {
|
||||
constants.push(Value::Nil);
|
||||
instructions.push(Instruction::new(Opcode::LoadConst, 0));
|
||||
}
|
||||
instructions.push(Instruction::simple(Opcode::ReturnValue));
|
||||
// 编码阶段校验字节码布局,诊断位置使用宿主 name 而不是伪造用户源码行列。
|
||||
let code = EndorCode::from_instructions(&instructions, constants, CodeLayout::default())?
|
||||
.with_location(name, "<tessera>", 1);
|
||||
// NativeContext 暂持代码根,输出函数会通过托管边继续拥有代码与常量。
|
||||
let code = cx.allocate(EndorCodeObject::new(code))?;
|
||||
// 驱动只读取常量,无需共享用户字典,空私有 globals 不污染 REPL 或主模块。
|
||||
let globals = cx.new_dict()?;
|
||||
// 函数作为本次原生调用的输出被提升,其余临时拥有根由 NativeContext 退出时释放。
|
||||
let driver = cx.new_function(name, code, globals)?;
|
||||
crate::ui_bridge::attach_desktop_type(cx, driver, "Function", desktop)?;
|
||||
Ok(driver)
|
||||
nexus::vm_sequence::build(cx, calls, name, &DesktopFunctions(desktop))
|
||||
}
|
||||
|
||||
/// source_layout/source_paint 安装一轮出现遍历时调用,生成固定大小的重复驱动,不按节点数展开字节码。
|
||||
/// callback 每次返回 Bool,false 退出;同帧回跳让所有出现和委托源函数共用当前 VM 的执行预算。
|
||||
/// 源布局/绘制适配调用,生成固定大小、同一帧回跳的重复驱动。
|
||||
pub fn repeat_call(
|
||||
cx: &mut NativeContext<'_>,
|
||||
callback: ObjectRef,
|
||||
name: &'static str,
|
||||
desktop: ObjectRef,
|
||||
) -> Result<ObjectRef, VmError> {
|
||||
// 内部 Advance 回调约定返回 Bool;repeat_while 生成的是 VM 真值条件跳转,不额外验证返回值必须是 Bool。
|
||||
// 退出后显式返回 Nil,回调的继续条件不会泄露为驱动返回值。
|
||||
let mut instructions = vec![
|
||||
Instruction::new(Opcode::LoadConst, 0),
|
||||
Instruction::simple(Opcode::PushNull),
|
||||
Instruction::new(Opcode::Call, 0),
|
||||
];
|
||||
repeat_while(&mut instructions)?;
|
||||
// 条件已由 PopJumpIfFalse 消费;退出时重新装 Nil,不能把最后条件冒充业务返回值。
|
||||
instructions.extend([
|
||||
Instruction::new(Opcode::LoadConst, 1),
|
||||
Instruction::simple(Opcode::ReturnValue),
|
||||
]);
|
||||
driver(
|
||||
cx,
|
||||
instructions,
|
||||
vec![Value::Object(callback), Value::Nil],
|
||||
name,
|
||||
desktop,
|
||||
)
|
||||
nexus::vm_sequence::repeat_call(cx, callback, name, &DesktopFunctions(desktop))
|
||||
}
|
||||
|
||||
/// source_layout/source_paint 的推进回调调用,为当前出现生成“调用源方法→collector 收结果→返回 true”的助手。
|
||||
/// 每次只捕获当前源函数/实参,不预先为全部节点建立助手帧;外层重复驱动再决定下一次出现。
|
||||
/// 单次源调用的收集器适配;保持 collector/function/实参顺序和原生输出根协议。
|
||||
pub fn collect_and_continue(
|
||||
cx: &mut NativeContext<'_>,
|
||||
collector: ObjectRef,
|
||||
@@ -96,140 +45,12 @@ pub fn collect_and_continue(
|
||||
name: &'static str,
|
||||
desktop: ObjectRef,
|
||||
) -> Result<ObjectRef, VmError> {
|
||||
// 常量布局固定为 collector、function、各实参、true。
|
||||
// function 或 collector 失败时不会装入最终 true,外层循环也不会自动跳过失败节点;本助手不捕获或重试源错误。
|
||||
// 先把 collector 的调用前缀压栈,再执行 function,使其返回值直接成为 collector 的唯一实参。
|
||||
// count 同时确定 Call 的显式参数数和 true 常量的池位置,不能把 collector 的一参计入它。
|
||||
let count = arguments.len();
|
||||
// 先保存两个 callable,再追加业务实参;这份强边关系使源调用挂起期间输入仍可达。
|
||||
let mut constants = vec![Value::Object(collector), Value::Object(function)];
|
||||
constants.extend(arguments);
|
||||
constants.push(Value::Bool(true));
|
||||
// 先压 collector 的调用前缀,再压 function 的调用前缀;内部返回值自然成为外部单一实参。
|
||||
let mut instructions = vec![
|
||||
Instruction::new(Opcode::LoadConst, 0),
|
||||
Instruction::simple(Opcode::PushNull),
|
||||
Instruction::new(Opcode::LoadConst, 1),
|
||||
Instruction::simple(Opcode::PushNull),
|
||||
];
|
||||
for index in 0..count {
|
||||
// 参数常量从 2 开始,0/1 已被 collector/function 占用,保持源方法原始实参顺序。
|
||||
instructions.push(Instruction::new(Opcode::LoadConst, index as u32 + 2));
|
||||
}
|
||||
// 收集器返回值不参与外层调度;丢弃后返回 true,通知重复驱动继续取下一项。
|
||||
instructions.extend([
|
||||
Instruction::new(Opcode::Call, count as u32),
|
||||
Instruction::new(Opcode::Call, 1),
|
||||
Instruction::simple(Opcode::PopTop),
|
||||
Instruction::new(Opcode::LoadConst, count as u32 + 2),
|
||||
Instruction::simple(Opcode::ReturnValue),
|
||||
]);
|
||||
driver(cx, instructions, constants, name, desktop)
|
||||
}
|
||||
|
||||
/// repeat_call/collect_and_continue 的共同分配助手,把已组装指令与常量变成有宿主 Function 类型的 callable。
|
||||
fn driver(
|
||||
cx: &mut NativeContext<'_>,
|
||||
instructions: Vec<Instruction>,
|
||||
constants: Vec<Value>,
|
||||
name: &'static str,
|
||||
desktop: ObjectRef,
|
||||
) -> Result<ObjectRef, VmError> {
|
||||
// 编码常量池与指令后带上宿主诊断位置;字节码有效性由 Aster 的代码构造接口检查。
|
||||
let code = EndorCode::from_instructions(&instructions, constants, CodeLayout::default())?
|
||||
.with_location(name, "<tessera>", 1);
|
||||
// NativeContext 跟踪临时代码根;函数的 trace 边持有代码,不能只靠 Rust ObjectRef 数值保活。
|
||||
let code = cx.allocate(EndorCodeObject::new(code))?;
|
||||
// 生成驱动不查用户名字,私有 globals 隔离它的空命名环境。
|
||||
let globals = cx.new_dict()?;
|
||||
// 返回函数根由原生输出机制提升,代码和 globals 的临时根在域结束后可安全清理。
|
||||
let function = cx.new_function(name, code, globals)?;
|
||||
crate::ui_bridge::attach_desktop_type(cx, function, "Function", desktop)?;
|
||||
Ok(function)
|
||||
}
|
||||
|
||||
/// repeat_call 和本模块测试调用,在现有指令尾部追加消费 Bool 条件的分支与回跳。
|
||||
/// true 回到本驱动偏移零,false 跳过回跳指令;不新建调用帧,因此不会用递归栈模拟循环。
|
||||
pub fn repeat_while(instructions: &mut Vec<Instruction>) -> Result<(), VmError> {
|
||||
// 跳转单位是编码后的双字节 code unit,不是 Instruction 数量。
|
||||
// 大操作数会生成 EXTENDED_ARG,因此必须编码后计算实际长度。
|
||||
let body = Instruction::encode_all(instructions)?.len() / 2;
|
||||
// 先用最短零操作数估计回跳宽度,下面迭代直到最终操作数与编码宽度自洽。
|
||||
let mut back = Instruction::new(Opcode::JumpBackward, 0);
|
||||
// 回跳距离包含自身宽度;而距离变大又可能扩大自身编码宽度。
|
||||
// 迭代到宽度/距离一致后,false 跳过回跳指令,true 回到整个驱动的起点。
|
||||
loop {
|
||||
// units 是当前回跳指令实际占用的 code unit,可能因 EXTENDED_ARG 大于一。
|
||||
let units = Instruction::encode_all(&[back])?.len() / 2;
|
||||
// 距离覆盖原 body、一个条件分支和回跳自身;目标为开头,不是仅回到上一个 Call。
|
||||
let distance = u32::try_from(body + 1 + units)
|
||||
.map_err(|_| VmError::ExecutionLimit("layout bytecode"))?;
|
||||
if back.argument == distance {
|
||||
// 已收敛时 false 跳过 units 个单元,true 落到 JumpBackward 回到开头。
|
||||
instructions.push(Instruction::new(Opcode::PopJumpIfFalse, units as u32));
|
||||
instructions.push(back);
|
||||
return Ok(());
|
||||
}
|
||||
// 更新操作数后再次编码量宽度;不能只计算一次,跨 255 等边界可能新增 EXTENDED_ARG。
|
||||
back.argument = distance;
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use endor_core::{ExecutionLimits, Vm};
|
||||
#[test]
|
||||
/// Rust 测试框架调用,构造大于单字节跳距的循环,分别验证退出、指令预算及无泄漏清理。
|
||||
fn repeated_bytecode_handles_extended_operands_and_keeps_one_frame() {
|
||||
// 300 个 Nop 强制跨越单字节跳转距离:false 应正常退出;true 应耗尽指令预算,
|
||||
// 而非耗尽帧预算,从而验证循环确实复用同一个执行帧。
|
||||
for condition in [false, true] {
|
||||
// Nop 扩大 body 编码长度,与实际布局节点数量无关,直接覆盖回跳扩展操作数的边界。
|
||||
let mut instructions = vec![Instruction::simple(Opcode::Nop); 300];
|
||||
instructions.push(Instruction::new(Opcode::LoadConst, 0));
|
||||
repeat_while(&mut instructions).unwrap();
|
||||
instructions.extend([
|
||||
Instruction::new(Opcode::LoadConst, 1),
|
||||
Instruction::simple(Opcode::ReturnValue),
|
||||
]);
|
||||
// 条件从常量池读取,false 分支跳过回跳后装入 Nil 并正常返回。
|
||||
let code = EndorCode::from_instructions(
|
||||
&instructions,
|
||||
vec![Value::Bool(condition), Value::Nil],
|
||||
CodeLayout::default(),
|
||||
)
|
||||
.unwrap();
|
||||
// 每种条件独立 VM,统计回收时不受另一轮遗留对象影响。
|
||||
let mut vm = Vm::new().unwrap();
|
||||
// 将纯代码值注册到 VM,执行结束后显式释放此拥有根。
|
||||
let code = vm.new_code(code).unwrap();
|
||||
// 空全局字典满足执行接口,不引入额外用户对象。
|
||||
let globals = vm.new_dict().unwrap();
|
||||
// 故意只允许一帧:如果实现递归重复而非同帧跳转,会得到错误的帧数耗尽。
|
||||
let result = vm.execute_with_limits(
|
||||
code,
|
||||
globals,
|
||||
ExecutionLimits {
|
||||
max_frames: 1,
|
||||
max_instructions: 1000,
|
||||
},
|
||||
);
|
||||
if condition {
|
||||
// true 永不自然退出,应耗尽 instructions 而非 frames,证明循环复用了同一帧。
|
||||
assert!(matches!(
|
||||
result,
|
||||
Err(VmError::ExecutionLimit("instructions"))
|
||||
));
|
||||
} else {
|
||||
// false 只走一次 body 然后返回 Nil,证明分支跳过长度包含完整扩展回跳指令。
|
||||
assert_eq!(result.unwrap(), Value::Nil);
|
||||
}
|
||||
vm.release(code).unwrap();
|
||||
vm.release(globals).unwrap();
|
||||
// 释放代码与全局字典后执行循环回收,确认生成的常量/函数没有遗留托管对象。
|
||||
vm.collect_cycles();
|
||||
assert_eq!(vm.object_count(), 0);
|
||||
}
|
||||
}
|
||||
nexus::vm_sequence::collect_and_continue(
|
||||
cx,
|
||||
collector,
|
||||
function,
|
||||
arguments,
|
||||
name,
|
||||
&DesktopFunctions(desktop),
|
||||
)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user