331 lines
10 KiB
Rust
331 lines
10 KiB
Rust
use base64::{Engine as _, engine::general_purpose::STANDARD};
|
|
use prometeu_bytecode::Value as VmValue;
|
|
use prometeu_hal::InputSignals;
|
|
use prometeu_system::CrashReport;
|
|
use prometeu_vm::VmInitError;
|
|
use serde::{Deserialize, Serialize};
|
|
use serde_json::{Value, json};
|
|
use std::io;
|
|
|
|
use crate::{CapturedFrame, HostError, HostExecutionStatus, HostState};
|
|
|
|
pub const CAPABILITIES: &[&str] = &[
|
|
"boot",
|
|
"reset",
|
|
"set_input",
|
|
"clear_input",
|
|
"advance",
|
|
"capture",
|
|
"get_state",
|
|
"get_fault",
|
|
"cancel",
|
|
"shutdown",
|
|
];
|
|
|
|
#[derive(Clone, Debug, Serialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct Limits {
|
|
pub max_frames: u64,
|
|
pub max_command_bytes: usize,
|
|
pub max_response_bytes: usize,
|
|
pub handshake_timeout_ms: u64,
|
|
pub call_timeout_ms: u64,
|
|
pub shutdown_timeout_ms: u64,
|
|
}
|
|
|
|
impl Default for Limits {
|
|
fn default() -> Self {
|
|
Self {
|
|
max_frames: 600,
|
|
max_command_bytes: 64 * 1024,
|
|
max_response_bytes: 32 * 1024 * 1024,
|
|
handshake_timeout_ms: 5_000,
|
|
call_timeout_ms: 60_000,
|
|
shutdown_timeout_ms: 5_000,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Limits {
|
|
pub fn validate(&self) -> io::Result<()> {
|
|
if self.max_frames == 0
|
|
|| self.max_command_bytes < 4096
|
|
|| self.max_response_bytes < 4096
|
|
|| self.handshake_timeout_ms == 0
|
|
|| self.call_timeout_ms == 0
|
|
|| self.shutdown_timeout_ms == 0
|
|
{
|
|
return Err(io::Error::new(
|
|
io::ErrorKind::InvalidInput,
|
|
"limits must be positive and message bounds at least 4096 bytes",
|
|
));
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
#[serde(deny_unknown_fields, rename_all = "camelCase")]
|
|
pub(super) struct Request {
|
|
pub request_id: String,
|
|
pub command: String,
|
|
pub params: Value,
|
|
}
|
|
|
|
pub(super) fn valid_id(id: &str) -> bool {
|
|
!id.is_empty() && id.len() <= 128
|
|
}
|
|
|
|
#[derive(Debug, Deserialize, Serialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub(super) struct Version {
|
|
pub major: u32,
|
|
pub minor: u32,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
#[serde(deny_unknown_fields, rename_all = "camelCase")]
|
|
pub(super) struct Initialize {
|
|
pub protocol_version: Version,
|
|
pub required_capabilities: Vec<String>,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub(super) struct Boot {
|
|
pub path: String,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub(super) struct Advance {
|
|
pub frames: u64,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize)]
|
|
#[serde(deny_unknown_fields, rename_all = "camelCase")]
|
|
pub(super) struct Cancel {
|
|
pub target_request_id: String,
|
|
}
|
|
|
|
#[derive(Debug, Default, Deserialize)]
|
|
#[serde(default, deny_unknown_fields, rename_all = "camelCase")]
|
|
pub(super) struct Input {
|
|
up: bool,
|
|
down: bool,
|
|
left: bool,
|
|
right: bool,
|
|
a: bool,
|
|
b: bool,
|
|
x: bool,
|
|
y: bool,
|
|
l: bool,
|
|
r: bool,
|
|
start: bool,
|
|
select: bool,
|
|
touch: bool,
|
|
touch_x: i32,
|
|
touch_y: i32,
|
|
}
|
|
|
|
impl From<Input> for InputSignals {
|
|
fn from(s: Input) -> Self {
|
|
Self {
|
|
up_signal: s.up,
|
|
down_signal: s.down,
|
|
left_signal: s.left,
|
|
right_signal: s.right,
|
|
a_signal: s.a,
|
|
b_signal: s.b,
|
|
x_signal: s.x,
|
|
y_signal: s.y,
|
|
l_signal: s.l,
|
|
r_signal: s.r,
|
|
start_signal: s.start,
|
|
select_signal: s.select,
|
|
f_signal: s.touch,
|
|
x_pos: s.touch_x,
|
|
y_pos: s.touch_y,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub(super) enum Command {
|
|
Initialize(Initialize),
|
|
Boot(Boot),
|
|
Reset,
|
|
SetInput(Input),
|
|
ClearInput,
|
|
Advance(Advance),
|
|
Capture,
|
|
GetState,
|
|
GetFault,
|
|
Cancel(Cancel),
|
|
Shutdown,
|
|
}
|
|
|
|
fn params<T: serde::de::DeserializeOwned>(value: Value) -> Result<T, WireError> {
|
|
serde_json::from_value(value).map_err(|e| WireError::new("invalid_params", e.to_string()))
|
|
}
|
|
|
|
fn empty(value: &Value) -> Result<(), WireError> {
|
|
if value.as_object().is_some_and(|v| v.is_empty()) {
|
|
Ok(())
|
|
} else {
|
|
Err(WireError::new("invalid_params", "expected an empty params object"))
|
|
}
|
|
}
|
|
|
|
pub(super) fn parse(req: Request) -> Result<(String, Command), WireError> {
|
|
if !valid_id(&req.request_id) {
|
|
return Err(WireError::new("invalid_request", "requestId must contain 1..128 UTF-8 bytes"));
|
|
}
|
|
let command = match req.command.as_str() {
|
|
"initialize" => Command::Initialize(params(req.params)?),
|
|
"boot" => {
|
|
let p: Boot = params(req.params)?;
|
|
if p.path.trim().is_empty() {
|
|
return Err(WireError::new("invalid_params", "path is empty"));
|
|
}
|
|
Command::Boot(p)
|
|
}
|
|
"advance" => Command::Advance(params(req.params)?),
|
|
"set_input" => Command::SetInput(params(req.params)?),
|
|
"cancel" => {
|
|
let p: Cancel = params(req.params)?;
|
|
if !valid_id(&p.target_request_id) {
|
|
return Err(WireError::new("invalid_params", "invalid targetRequestId"));
|
|
}
|
|
Command::Cancel(p)
|
|
}
|
|
"reset" | "clear_input" | "capture" | "get_state" | "get_fault" | "shutdown" => {
|
|
empty(&req.params)?;
|
|
match req.command.as_str() {
|
|
"reset" => Command::Reset,
|
|
"clear_input" => Command::ClearInput,
|
|
"capture" => Command::Capture,
|
|
"get_state" => Command::GetState,
|
|
"get_fault" => Command::GetFault,
|
|
_ => Command::Shutdown,
|
|
}
|
|
}
|
|
_ => return Err(WireError::new("unknown_command", "unknown command")),
|
|
};
|
|
Ok((req.request_id, command))
|
|
}
|
|
|
|
#[derive(Debug, Serialize)]
|
|
pub(super) struct WireError {
|
|
pub code: &'static str,
|
|
pub message: String,
|
|
pub details: Value,
|
|
}
|
|
|
|
impl WireError {
|
|
pub fn new(code: &'static str, message: impl Into<String>) -> Self {
|
|
Self { code, message: message.into(), details: json!({}) }
|
|
}
|
|
}
|
|
|
|
pub(super) fn host_error(error: HostError) -> WireError {
|
|
let (code, details) = match &error {
|
|
HostError::AlreadyBooted => ("already_booted", json!({})),
|
|
HostError::BootFailed { reason, report } => {
|
|
("boot_failed", json!({"reason":reason,"fault":report.as_ref().map(fault)}))
|
|
}
|
|
HostError::InvalidState { operation, status } => {
|
|
("invalid_state", json!({"operation":operation,"status":status_name(*status)}))
|
|
}
|
|
HostError::FrameAdvanceWatchdogExpired { host_tick_limit } => {
|
|
("watchdog_expired", json!({"hostTickLimit":host_tick_limit}))
|
|
}
|
|
HostError::FrameNotPublished { previous } => {
|
|
("frame_not_published", json!({"previousFrameId":previous.map(|id| id.get())}))
|
|
}
|
|
HostError::NoFrameAvailable => ("no_frame_available", json!({})),
|
|
};
|
|
WireError { code, message: error.to_string(), details }
|
|
}
|
|
|
|
fn status_name(status: HostExecutionStatus) -> &'static str {
|
|
match status {
|
|
HostExecutionStatus::Running => "running",
|
|
HostExecutionStatus::Paused => "paused",
|
|
HostExecutionStatus::Terminated => "terminated",
|
|
HostExecutionStatus::Faulted => "faulted",
|
|
}
|
|
}
|
|
|
|
fn stack_value(value: &VmValue) -> Value {
|
|
match value {
|
|
VmValue::Int32(v) => json!({"kind":"int32","value":v}),
|
|
VmValue::Int64(v) => json!({"kind":"int64","value":v.to_string()}),
|
|
VmValue::Float(v) => json!({"kind":"float64","value":v.to_string()}),
|
|
VmValue::Boolean(v) => json!({"kind":"boolean","value":v}),
|
|
VmValue::String(v) => json!({"kind":"string","value":v.as_ref()}),
|
|
VmValue::HeapRef(v) => json!({"kind":"heap_ref","value":v.0}),
|
|
VmValue::Null => json!({"kind":"null","value":null}),
|
|
}
|
|
}
|
|
|
|
pub(super) fn state(s: HostState) -> Value {
|
|
json!({"pc":s.pc,"stackTop":s.stack_top.iter().map(stack_value).collect::<Vec<_>>(),
|
|
"logicalFrameIndex":s.frame_index,"tickIndex":s.tick_index,"appId":s.app_id,
|
|
"status":status_name(s.status)})
|
|
}
|
|
|
|
pub(super) fn fault(report: &CrashReport) -> Value {
|
|
let mut result = json!({"kind":report.kind(),"pc":report.pc(),"summary":report.summary()});
|
|
match report {
|
|
CrashReport::VmTrap { trap } => {
|
|
result["trap"] = json!({"code":trap.code,"opcode":trap.opcode,
|
|
"message":trap.message,"pc":trap.pc,"span":trap.span});
|
|
}
|
|
CrashReport::VmPanic { message, .. } => {
|
|
result["message"] = json!(message);
|
|
}
|
|
CrashReport::VmInit { error } => {
|
|
let code = match error {
|
|
VmInitError::InvalidFormat => "invalid_format",
|
|
VmInitError::UnsupportedFormat => "unsupported_format",
|
|
VmInitError::ImageLoadFailed(_) => "image_load_failed",
|
|
VmInitError::LoaderPatchFailed(_) => "loader_patch_failed",
|
|
VmInitError::EntrypointNotFound => "entrypoint_not_found",
|
|
VmInitError::VerificationFailed(_) => "verification_failed",
|
|
};
|
|
result["initError"] = json!({"code":code,"message":format!("{error:?}")});
|
|
}
|
|
}
|
|
result
|
|
}
|
|
|
|
pub(super) fn capture(c: CapturedFrame) -> Result<Value, WireError> {
|
|
let frame = c.frame;
|
|
let width = u32::try_from(frame.width)
|
|
.map_err(|_| WireError::new("capture_failed", "width exceeds PNG limit"))?;
|
|
let height = u32::try_from(frame.height)
|
|
.map_err(|_| WireError::new("capture_failed", "height exceeds PNG limit"))?;
|
|
let mut rgba = Vec::new();
|
|
for y in 0..frame.height {
|
|
for pixel in frame.row(y).ok_or_else(|| WireError::new("capture_failed", "invalid row"))? {
|
|
rgba.extend_from_slice(&pixel.to_be_bytes());
|
|
}
|
|
}
|
|
let mut bytes = Vec::new();
|
|
{
|
|
let mut encoder = png::Encoder::new(&mut bytes, width, height);
|
|
encoder.set_color(png::ColorType::Rgba);
|
|
encoder.set_depth(png::BitDepth::Eight);
|
|
let mut writer =
|
|
encoder.write_header().map_err(|e| WireError::new("capture_failed", e.to_string()))?;
|
|
writer
|
|
.write_image_data(&rgba)
|
|
.map_err(|e| WireError::new("capture_failed", e.to_string()))?;
|
|
writer.finish().map_err(|e| WireError::new("capture_failed", e.to_string()))?;
|
|
}
|
|
Ok(json!({"mimeType":"image/png","encoding":"base64","data":STANDARD.encode(bytes),
|
|
"width":width,"height":height,"stridePixels":frame.stride_pixels,"pixelFormat":"RGBA8888",
|
|
"logicalFrameIndex":c.logical_frame_index,"frameId":frame.frame_id.get()}))
|
|
}
|