implements PLN-0058
Intrepid/Prometeu/Runtime/pipeline/head This commit looks good
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good

This commit is contained in:
2026-05-15 06:55:26 +01:00
parent bfe900797f
commit 4d2ea6400d
19 changed files with 499 additions and 281 deletions
@@ -1,31 +1,26 @@
use crate::CrashReport;
use crate::VirtualMachineRuntime;
use crate::fs::{FsBackend, FsState, VirtualFS};
use crate::os::{LifecycleError, LifecycleOperation};
use crate::fs::{FsState, VirtualFS};
use crate::os::{FsFacade, LifecycleFacade, SessionsFacade, VmFacade, WindowFacade};
use crate::process::ProcessManager;
use crate::services::memcard::MemcardService;
use crate::services::window_manager::WindowManager;
use crate::task::TaskManager;
use crate::task::{TaskId, TaskState};
use prometeu_hal::cartridge::Cartridge;
use prometeu_hal::log::{LogLevel, LogService, LogSource};
use prometeu_hal::log::{LogEvent, LogLevel, LogService, LogSource};
use prometeu_hal::telemetry::CertificationConfig;
use prometeu_hal::{HardwareBridge, InputSignals};
use prometeu_vm::VirtualMachine;
use std::collections::HashMap;
use std::sync::Arc;
pub struct SystemOS {
pub vm_runtime: VirtualMachineRuntime,
pub process_manager: ProcessManager,
pub task_manager: TaskManager,
pub window_manager: WindowManager,
pub log_service: LogService,
pub fs: VirtualFS,
pub fs_state: FsState,
pub memcard: MemcardService,
pub open_files: HashMap<u32, String>,
pub next_handle: u32,
pub(super) vm_runtime: VirtualMachineRuntime,
pub(super) process_manager: ProcessManager,
pub(super) task_manager: TaskManager,
pub(super) window_manager: WindowManager,
pub(super) log_service: LogService,
pub(super) fs: VirtualFS,
pub(super) fs_state: FsState,
pub(super) memcard: MemcardService,
pub(super) open_files: HashMap<u32, String>,
pub(super) next_handle: u32,
}
impl SystemOS {
@@ -56,156 +51,47 @@ impl SystemOS {
self.vm_runtime.log(&mut self.log_service, level, source, tag, msg);
}
pub fn initialize_vm(
&mut self,
vm: &mut VirtualMachine,
cartridge: &Cartridge,
) -> Result<(), CrashReport> {
self.clear_cartridge_service_state();
self.vm_runtime.initialize_vm(&mut self.log_service, vm, cartridge)
pub fn recent_logs(&self, n: usize) -> Vec<LogEvent> {
self.log_service.get_recent(n)
}
pub fn tick_vm(
&mut self,
vm: &mut VirtualMachine,
signals: &InputSignals,
hw: &mut dyn HardwareBridge,
) -> Option<CrashReport> {
self.vm_runtime.tick(
&mut self.log_service,
&mut self.fs,
&mut self.fs_state,
&mut self.memcard,
&mut self.open_files,
&mut self.next_handle,
vm,
signals,
hw,
)
pub fn logs_after(&self, seq: u64) -> Vec<LogEvent> {
self.log_service.get_after(seq)
}
pub fn mount_fs(&mut self, backend: Box<dyn FsBackend>) {
self.vm_runtime.mount_fs(&mut self.log_service, &mut self.fs, &mut self.fs_state, backend);
pub fn lifecycle(&mut self) -> LifecycleFacade<'_> {
LifecycleFacade { os: self }
}
pub fn unmount_fs(&mut self) {
self.fs.unmount();
self.fs_state = FsState::Unmounted;
pub fn sessions(&mut self) -> SessionsFacade<'_> {
SessionsFacade { os: self }
}
fn clear_cartridge_service_state(&mut self) {
pub fn vm(&mut self) -> VmFacade<'_> {
VmFacade { os: self }
}
pub fn fs(&mut self) -> FsFacade<'_> {
FsFacade { os: self }
}
pub fn window(&mut self) -> WindowFacade<'_> {
WindowFacade { os: self }
}
pub(super) fn clear_cartridge_service_state(&mut self) {
self.open_files.clear();
self.next_handle = 1;
self.memcard.clear_all_staging();
}
pub fn create_vm_game_task(&mut self, app_id: u32, title: impl Into<String>) -> TaskId {
let title = title.into();
let process_id = self.process_manager.spawn_vm_game(app_id, title.clone());
let task_id = self.task_manager.create_game_task(process_id, app_id, title);
self.set_foreground_task(task_id)
.expect("newly created game task should have an associated process");
task_id
}
pub fn create_vm_shell_task(&mut self, app_id: u32, title: impl Into<String>) -> TaskId {
let title = title.into();
let process_id = self.process_manager.spawn_vm_shell(app_id, title.clone());
let task_id = self.task_manager.create_shell_task(process_id, app_id, title);
self.set_foreground_task(task_id)
.expect("newly created shell task should have an associated process");
task_id
}
pub fn create_native_shell_task(&mut self, app_id: u32, title: impl Into<String>) -> TaskId {
let title = title.into();
let process_id = self.process_manager.spawn_native_shell(app_id, title.clone());
let task_id = self.task_manager.create_shell_task(process_id, app_id, title);
self.set_foreground_task(task_id)
.expect("newly created native shell task should have an associated process");
task_id
}
pub fn set_foreground_task(&mut self, task_id: TaskId) -> Result<(), LifecycleError> {
let process_id = self.process_id_for_task(task_id)?;
self.task_manager.set_foreground(task_id);
self.process_manager.mark_running(process_id);
Ok(())
}
pub fn suspend_task(&mut self, task_id: TaskId) -> Result<(), LifecycleError> {
let process_id = self.process_id_for_task(task_id)?;
self.task_manager.mark_suspended(task_id);
self.process_manager.mark_suspended(process_id);
Ok(())
}
pub fn resume_task(&mut self, task_id: TaskId) -> Result<(), LifecycleError> {
let task = self.task_manager.get(task_id).ok_or(LifecycleError::TaskNotFound(task_id))?;
if task.state != TaskState::Suspended {
return Err(LifecycleError::InvalidTransition {
task_id,
from: task.state,
operation: LifecycleOperation::Resume,
});
}
let process_id = self.process_id_for_task(task_id)?;
self.task_manager.set_foreground(task_id);
self.process_manager.mark_running(process_id);
Ok(())
}
pub fn close_task(&mut self, task_id: TaskId) -> Result<(), LifecycleError> {
let process_id = self.process_id_for_task(task_id)?;
self.task_manager.close_task(task_id);
self.process_manager.mark_stopped(process_id);
Ok(())
}
pub fn crash_task(
&mut self,
task_id: TaskId,
_report: Option<&CrashReport>,
) -> Result<(), LifecycleError> {
let process_id = self.process_id_for_task(task_id)?;
self.task_manager.mark_crashed(task_id);
self.process_manager.mark_crashed(process_id);
Ok(())
}
fn process_id_for_task(
&self,
task_id: TaskId,
) -> Result<crate::process::ProcessId, LifecycleError> {
let task = self.task_manager.get(task_id).ok_or(LifecycleError::TaskNotFound(task_id))?;
if !self.process_manager.contains(task.process_id) {
return Err(LifecycleError::ProcessNotFound(task.process_id));
}
Ok(task.process_id)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::os::{LifecycleError, LifecycleOperation};
use crate::process::ProcessState;
use crate::task::{TaskId, TaskState};
fn process_state_for_task(os: &SystemOS, task_id: TaskId) -> ProcessState {
let task = os.task_manager.get(task_id).expect("task should exist");
@@ -215,10 +101,10 @@ mod tests {
#[test]
fn set_foreground_task_marks_task_and_process_running() {
let mut os = SystemOS::new(None);
let task_id = os.create_vm_game_task(42, "Sector Crawl");
let task_id = os.sessions().create_vm_game_task(42, "Sector Crawl");
os.suspend_task(task_id).expect("suspend should succeed");
os.set_foreground_task(task_id).expect("foreground should succeed");
os.lifecycle().suspend_task(task_id).expect("suspend should succeed");
os.lifecycle().set_foreground_task(task_id).expect("foreground should succeed");
assert_eq!(
os.task_manager.get(task_id).expect("task should exist").state,
@@ -230,9 +116,9 @@ mod tests {
#[test]
fn suspend_task_marks_task_and_process_suspended() {
let mut os = SystemOS::new(None);
let task_id = os.create_vm_game_task(42, "Sector Crawl");
let task_id = os.sessions().create_vm_game_task(42, "Sector Crawl");
os.suspend_task(task_id).expect("suspend should succeed");
os.lifecycle().suspend_task(task_id).expect("suspend should succeed");
assert_eq!(
os.task_manager.get(task_id).expect("task should exist").state,
@@ -244,10 +130,10 @@ mod tests {
#[test]
fn resume_task_marks_suspended_task_foreground_and_process_running() {
let mut os = SystemOS::new(None);
let task_id = os.create_vm_game_task(42, "Sector Crawl");
let task_id = os.sessions().create_vm_game_task(42, "Sector Crawl");
os.suspend_task(task_id).expect("suspend should succeed");
os.resume_task(task_id).expect("resume should succeed");
os.lifecycle().suspend_task(task_id).expect("suspend should succeed");
os.lifecycle().resume_task(task_id).expect("resume should succeed");
assert_eq!(
os.task_manager.get(task_id).expect("task should exist").state,
@@ -259,10 +145,10 @@ mod tests {
#[test]
fn close_task_marks_task_closed_and_process_stopped_without_removing_entities() {
let mut os = SystemOS::new(None);
let task_id = os.create_vm_game_task(42, "Sector Crawl");
let task_id = os.sessions().create_vm_game_task(42, "Sector Crawl");
let process_id = os.task_manager.get(task_id).expect("task should exist").process_id;
os.close_task(task_id).expect("close should succeed");
os.lifecycle().close_task(task_id).expect("close should succeed");
assert_eq!(
os.task_manager.get(task_id).expect("task should remain").state,
@@ -277,9 +163,9 @@ mod tests {
#[test]
fn crash_task_marks_task_and_process_crashed() {
let mut os = SystemOS::new(None);
let task_id = os.create_vm_game_task(42, "Sector Crawl");
let task_id = os.sessions().create_vm_game_task(42, "Sector Crawl");
os.crash_task(task_id, None).expect("crash should succeed");
os.lifecycle().crash_task(task_id, None).expect("crash should succeed");
assert_eq!(
os.task_manager.get(task_id).expect("task should exist").state,
@@ -292,28 +178,34 @@ mod tests {
fn lifecycle_operation_missing_task_returns_typed_error() {
let mut os = SystemOS::new(None);
assert_eq!(os.suspend_task(TaskId(999)), Err(LifecycleError::TaskNotFound(TaskId(999))));
assert_eq!(
os.lifecycle().suspend_task(TaskId(999)),
Err(LifecycleError::TaskNotFound(TaskId(999)))
);
}
#[test]
fn lifecycle_operation_missing_process_returns_typed_error() {
let mut os = SystemOS::new(None);
let task_id = os.create_vm_game_task(42, "Sector Crawl");
let task_id = os.sessions().create_vm_game_task(42, "Sector Crawl");
let process_id = os.task_manager.get(task_id).expect("task should exist").process_id;
os.process_manager.mark_stopped(process_id);
os.process_manager.remove_stopped();
assert_eq!(os.suspend_task(task_id), Err(LifecycleError::ProcessNotFound(process_id)));
assert_eq!(
os.lifecycle().suspend_task(task_id),
Err(LifecycleError::ProcessNotFound(process_id))
);
}
#[test]
fn resume_task_from_non_suspended_state_returns_invalid_transition() {
let mut os = SystemOS::new(None);
let task_id = os.create_vm_game_task(42, "Sector Crawl");
let task_id = os.sessions().create_vm_game_task(42, "Sector Crawl");
assert_eq!(
os.resume_task(task_id),
os.lifecycle().resume_task(task_id),
Err(LifecycleError::InvalidTransition {
task_id,
from: TaskState::Foreground,