1117 lines
43 KiB
Rust
1117 lines
43 KiB
Rust
use super::*;
|
|
use prometeu_hal::memcard::MemcardIoError;
|
|
use std::sync::{Arc, Mutex};
|
|
|
|
#[derive(Clone)]
|
|
struct Disk {
|
|
volatile: Vec<u8>,
|
|
durable: Vec<u8>,
|
|
calls: usize,
|
|
fail: Option<usize>,
|
|
sync_then_fail: bool,
|
|
}
|
|
struct Store(Arc<Mutex<Disk>>);
|
|
impl MemcardStorage for Store {
|
|
fn len(&self) -> std::result::Result<u64, MemcardIoError> {
|
|
Ok(IMAGE_BYTES)
|
|
}
|
|
fn read_only(&self) -> bool {
|
|
false
|
|
}
|
|
fn read_at(&mut self, offset: u64, out: &mut [u8]) -> std::result::Result<(), MemcardIoError> {
|
|
let mut d = self.0.lock().unwrap();
|
|
d.calls += 1;
|
|
if d.fail == Some(d.calls) {
|
|
return Err(MemcardIoError::IoError);
|
|
}
|
|
out.copy_from_slice(&d.volatile[offset as usize..offset as usize + out.len()]);
|
|
Ok(())
|
|
}
|
|
fn write_at(&mut self, offset: u64, bytes: &[u8]) -> std::result::Result<(), MemcardIoError> {
|
|
let mut d = self.0.lock().unwrap();
|
|
d.calls += 1;
|
|
let start = offset as usize;
|
|
if d.fail == Some(d.calls) {
|
|
let half = bytes.len() / 2;
|
|
d.volatile[start..start + half].copy_from_slice(&bytes[..half]);
|
|
d.durable[start..start + half].copy_from_slice(&bytes[..half]);
|
|
return Err(MemcardIoError::IoError);
|
|
}
|
|
d.volatile[start..start + bytes.len()].copy_from_slice(bytes);
|
|
Ok(())
|
|
}
|
|
fn sync(&mut self) -> std::result::Result<(), MemcardIoError> {
|
|
let mut d = self.0.lock().unwrap();
|
|
d.calls += 1;
|
|
let fail = d.fail == Some(d.calls);
|
|
if !fail || d.sync_then_fail {
|
|
d.durable = d.volatile.clone();
|
|
}
|
|
if fail { Err(MemcardIoError::IoError) } else { Ok(()) }
|
|
}
|
|
}
|
|
fn disk() -> Arc<Mutex<Disk>> {
|
|
Arc::new(Mutex::new(Disk {
|
|
volatile: vec![0; IMAGE_BYTES as usize],
|
|
durable: vec![0; IMAGE_BYTES as usize],
|
|
calls: 0,
|
|
fail: None,
|
|
sync_then_fail: false,
|
|
}))
|
|
}
|
|
fn formatted() -> (Card, Arc<Mutex<Disk>>) {
|
|
let d = disk();
|
|
Card::format(&mut Store(d.clone()), [7; 16]).unwrap();
|
|
(Card::mount(Box::new(Store(d.clone()))).unwrap(), d)
|
|
}
|
|
fn add(card: &mut Card, app: u32, n: usize) {
|
|
let icon = [0; 560];
|
|
card.register(
|
|
Game {
|
|
app_id: app,
|
|
title: "game".into(),
|
|
data_format_version: 0,
|
|
created_at: 0,
|
|
slots: vec![0; n],
|
|
icon: Icon { offset: 0, frames: 1, duration: 1, crc32c: crc32c(&icon) },
|
|
},
|
|
&icon,
|
|
&PublicationControl::default(),
|
|
)
|
|
.unwrap();
|
|
}
|
|
fn reboot(d: &Arc<Mutex<Disk>>) -> Card {
|
|
{
|
|
let mut disk = d.lock().unwrap();
|
|
disk.volatile = disk.durable.clone();
|
|
disk.fail = None;
|
|
}
|
|
Card::mount(Box::new(Store(d.clone()))).unwrap()
|
|
}
|
|
#[test]
|
|
fn full_pool_rotates_and_empty_keeps_ownership() {
|
|
let (mut c, d) = formatted();
|
|
add(&mut c, 1, 64);
|
|
for i in 0..64 {
|
|
assert_eq!(
|
|
c.commit(i, &[i as u8], 0, &PublicationControl::default()).durable,
|
|
DurableResult::Success
|
|
);
|
|
}
|
|
let mut visited = std::collections::BTreeSet::new();
|
|
for i in 0..90 {
|
|
assert_eq!(
|
|
c.commit(0, &[i], 10, &PublicationControl::default()).durable,
|
|
DurableResult::Success
|
|
);
|
|
visited.insert(c.current().slots[0].block.unwrap());
|
|
}
|
|
assert!(visited.len() >= 5);
|
|
assert_eq!(c.commit(0, &[], 0, &PublicationControl::default()).durable, DurableResult::Success);
|
|
let r = reboot(&d);
|
|
assert!(r.current().slots[0].assigned);
|
|
assert_eq!(r.current().slots[0].block, None);
|
|
assert_eq!(r.current().slots[0].generation, 92);
|
|
assert_eq!(r.current().slots[0].update_at, 0);
|
|
}
|
|
#[test]
|
|
fn cut_every_commit_step_including_sync_that_persists_then_errors() {
|
|
let (mut c, d) = formatted();
|
|
add(&mut c, 1, 1);
|
|
c.commit(0, b"old", 7, &PublicationControl::default());
|
|
let initial = d.lock().unwrap().clone();
|
|
for persist in [false, true] {
|
|
for cut in 1..=12 {
|
|
let mut initial = initial.clone();
|
|
initial.calls = 0;
|
|
initial.fail = None;
|
|
initial.sync_then_fail = persist;
|
|
let d = Arc::new(Mutex::new(initial));
|
|
let mut card = Card::mount(Box::new(Store(d.clone()))).unwrap();
|
|
{
|
|
let mut disk = d.lock().unwrap();
|
|
disk.calls = 0;
|
|
disk.fail = Some(cut);
|
|
}
|
|
let result = card.commit(0, b"new version", 1, &PublicationControl::default());
|
|
let mut recovered = reboot(&d);
|
|
let mut bytes = [0; 64];
|
|
let n = recovered.read_slot(0, &mut bytes).unwrap();
|
|
match result.durable {
|
|
DurableResult::Success => assert_eq!(&bytes[..n], b"new version"),
|
|
DurableResult::Failure => assert_eq!(&bytes[..n], b"old"),
|
|
DurableResult::Indeterminate => {
|
|
assert!(&bytes[..n] == b"old" || &bytes[..n] == b"new version")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#[test]
|
|
fn catalog_cuts_never_publish_partial_registration() {
|
|
let (c, d) = formatted();
|
|
drop(c);
|
|
let baseline = d.lock().unwrap().clone();
|
|
for cut in 1..=14 {
|
|
let d = Arc::new(Mutex::new(baseline.clone()));
|
|
let mut card = Card::mount(Box::new(Store(d.clone()))).unwrap();
|
|
{
|
|
let mut state = d.lock().unwrap();
|
|
state.calls = 0;
|
|
state.fail = Some(cut);
|
|
state.sync_then_fail = true;
|
|
}
|
|
let icon = [0; 560];
|
|
let _ = card.register(
|
|
Game {
|
|
app_id: 3,
|
|
title: "new".into(),
|
|
data_format_version: 0,
|
|
created_at: 0,
|
|
slots: vec![0; 2],
|
|
icon: Icon { offset: 0, frames: 1, duration: 1, crc32c: crc32c(&icon) },
|
|
},
|
|
&icon,
|
|
&PublicationControl::default(),
|
|
);
|
|
let recovered = reboot(&d);
|
|
let n = recovered.catalog.games.len();
|
|
assert!(n <= 1);
|
|
assert_eq!(recovered.current().slots.iter().filter(|s| s.assigned).count(), n * 2);
|
|
}
|
|
}
|
|
#[test]
|
|
fn corrupted_new_payload_recovers_old_map_with_diagnostic() {
|
|
let (mut c, d) = formatted();
|
|
add(&mut c, 1, 1);
|
|
c.commit(0, b"old", 7, &PublicationControl::default());
|
|
c.commit(0, b"new", 8, &PublicationControl::default());
|
|
let at = block_offset(c.current().slots[0].block.unwrap()).unwrap() as usize;
|
|
{
|
|
let mut disk = d.lock().unwrap();
|
|
disk.durable[at] ^= 1;
|
|
}
|
|
let mut r = reboot(&d);
|
|
assert!(r.recovered);
|
|
let mut out = [0; 8];
|
|
let n = r.read_slot(0, &mut out).unwrap();
|
|
assert_eq!(&out[..n], b"old");
|
|
}
|
|
#[test]
|
|
fn grow_shrink_removal_and_clean_reassignment() {
|
|
let (mut c, d) = formatted();
|
|
add(&mut c, 1, 2);
|
|
c.commit(1, b"private", 5, &PublicationControl::default());
|
|
c.grow(1, 4, &PublicationControl::default()).unwrap();
|
|
c.grow(1, 1, &PublicationControl::default()).unwrap();
|
|
assert_eq!(c.catalog.games[0].slots.len(), 4);
|
|
c.remove_game(1, &PublicationControl::default()).unwrap();
|
|
add(&mut c, 2, 4);
|
|
let r = reboot(&d);
|
|
assert!(
|
|
r.current().slots[..4].iter().all(|s| s.assigned && s.generation == 0 && s.block.is_none())
|
|
);
|
|
}
|
|
#[test]
|
|
fn cancellation_prevents_publication_and_generations_do_not_wrap() {
|
|
let (mut c, d) = formatted();
|
|
add(&mut c, 1, 1);
|
|
let token = PublicationControl::default();
|
|
token.cancel();
|
|
assert_eq!(c.commit(0, b"no", 1, &token).durable, DurableResult::Failure);
|
|
assert_eq!(reboot(&d).current().slots[0].generation, 0);
|
|
c.maps[c.active].as_mut().unwrap().slots[0].generation = u64::MAX;
|
|
assert_eq!(
|
|
c.commit(0, b"no", 1, &PublicationControl::default()).error,
|
|
Some(Error::CounterExhausted)
|
|
);
|
|
}
|
|
#[test]
|
|
fn quarantine_survives_remount_and_is_never_selected() {
|
|
let (mut c, d) = formatted();
|
|
add(&mut c, 1, 1);
|
|
c.quarantine(0, &PublicationControl::default()).unwrap();
|
|
let mut c = reboot(&d);
|
|
assert!(c.degraded);
|
|
c.commit(0, b"yes", 1, &PublicationControl::default());
|
|
assert_ne!(c.current().slots[0].block, Some(0));
|
|
assert!(reboot(&d).current().quarantine[0]);
|
|
}
|
|
|
|
#[test]
|
|
fn async_commit_protects_only_source_and_retains_result_without_occupying_lane() {
|
|
use crate::services::async_work::{
|
|
AsyncWorkLane, AsyncWorkLaneConfig, AsyncWorkLaneController,
|
|
};
|
|
use crate::services::memcard::session::{RequestState, Session};
|
|
use std::time::{Duration, Instant};
|
|
let (mut card, _) = formatted();
|
|
add(&mut card, 4, 2);
|
|
let mut session = Session::default();
|
|
let context = session.load_card(card, 4, 2, Session::required_bytes(2).unwrap()).unwrap();
|
|
session.write(context, 0, 0, b"save").unwrap();
|
|
let lane = Arc::new(AsyncWorkLane::default());
|
|
let now = Instant::now();
|
|
let id = session.commit(context, 0, 77, now, &lane).unwrap();
|
|
assert_eq!(session.write(context, 0, 0, b"bad"), Err(Error::Busy));
|
|
session.write(context, 1, 0, b"other").unwrap();
|
|
let mut bytes = [0; 4];
|
|
assert_eq!(session.read(context, 0, 0, &mut bytes), Ok(4));
|
|
assert_eq!(&bytes, b"save");
|
|
let mut controller =
|
|
AsyncWorkLaneController::start(AsyncWorkLaneConfig::default(), lane.clone());
|
|
let deadline = Instant::now() + Duration::from_secs(2);
|
|
while session.query(context, id).unwrap().state == RequestState::Pending {
|
|
assert!(Instant::now() < deadline);
|
|
session.poll(Instant::now());
|
|
std::thread::yield_now();
|
|
}
|
|
assert_eq!(session.query(context, id).unwrap().state, RequestState::Success);
|
|
let (tx, rx) = std::sync::mpsc::channel();
|
|
lane.submit_asset_load(move |_| {
|
|
tx.send(()).unwrap();
|
|
crate::services::async_work::AsyncWorkJobOutcome::Completed
|
|
})
|
|
.unwrap();
|
|
rx.recv_timeout(Duration::from_secs(1)).unwrap();
|
|
assert_eq!(session.commit(context, 1, 78, Instant::now(), &lane), Err(Error::Busy));
|
|
assert_eq!(session.descriptor(context, 0).unwrap().0.update_at, 77);
|
|
session.release_request(context, id).unwrap();
|
|
controller.stop().unwrap();
|
|
}
|
|
|
|
// The sentinel executes after the save on the single lane. Wall time only bounds
|
|
// a broken fixture; all watchdog observations use explicit simulated instants.
|
|
fn finish_queued_save(lane: Arc<crate::AsyncWorkLane>) {
|
|
let (tx, rx) = std::sync::mpsc::channel();
|
|
lane.submit_asset_load(move |_| {
|
|
tx.send(()).unwrap();
|
|
crate::services::async_work::AsyncWorkJobOutcome::Completed
|
|
})
|
|
.unwrap();
|
|
let mut controller =
|
|
crate::AsyncWorkLaneController::start(crate::AsyncWorkLaneConfig::default(), lane);
|
|
rx.recv_timeout(std::time::Duration::from_secs(5)).unwrap();
|
|
controller.stop().unwrap();
|
|
}
|
|
|
|
fn assert_guest_query(
|
|
session: &mut super::super::session::Session,
|
|
id: u64,
|
|
state: i64,
|
|
reason: i64,
|
|
) {
|
|
use prometeu_bytecode::Value;
|
|
use prometeu_hal::{
|
|
HostReturn, host_return::GuestStringAllocator, syscalls::Syscall, vm_fault::VmFault,
|
|
};
|
|
struct NoStrings;
|
|
impl GuestStringAllocator for NoStrings {
|
|
fn byte_limit(&self) -> u64 {
|
|
0
|
|
}
|
|
fn build(
|
|
&mut self,
|
|
_: usize,
|
|
_: &mut dyn FnMut(&mut dyn std::fmt::Write) -> std::fmt::Result,
|
|
) -> std::result::Result<Arc<str>, VmFault> {
|
|
panic!("MemQuery must not allocate strings")
|
|
}
|
|
}
|
|
let mut service = super::super::MemcardService::new();
|
|
std::mem::swap(session, &mut service.session);
|
|
let args = [Value::Int64(service.session.context() as i64), Value::Int64(id as i64)];
|
|
let mut values = Vec::with_capacity(Syscall::MemQuery.results_count());
|
|
let mut strings = NoStrings;
|
|
let mut ret = HostReturn::new(&mut values, Syscall::MemQuery.results_count(), &mut strings);
|
|
service.guest(Syscall::MemQuery, &args, &mut ret, 4, 0, true).unwrap();
|
|
assert!(!ret.overflowed());
|
|
assert!(ret.failure().is_none());
|
|
assert_eq!(values, vec![Value::Int64(0), Value::Int64(state), Value::Int64(reason)]);
|
|
std::mem::swap(session, &mut service.session);
|
|
}
|
|
|
|
#[test]
|
|
fn queued_memcard_watchdog_preserves_timeout_and_guest_reason() {
|
|
use super::super::session::{RequestReason, RequestState, Session};
|
|
use std::time::{Duration, Instant};
|
|
for bootstrap in [false, true] {
|
|
let (mut card, disk) = formatted();
|
|
add(&mut card, 4, 1);
|
|
let before = card.current().slots[0];
|
|
let mut s = Session::default();
|
|
let c = s.load_card(card, 4, 1, Session::required_bytes(1).unwrap()).unwrap();
|
|
s.write(c, 0, 0, b"pending").unwrap();
|
|
let lane = Arc::new(crate::AsyncWorkLane::default());
|
|
let now = Instant::now();
|
|
if bootstrap {
|
|
s.begin_boot();
|
|
}
|
|
let id = s.commit(c, 0, 7, now, &lane).unwrap();
|
|
if bootstrap {
|
|
s.finish_boot(true, &lane, now).unwrap();
|
|
}
|
|
s.poll(now + Duration::from_millis(499));
|
|
assert_guest_query(&mut s, id, 0, 0);
|
|
for _ in 0..2 {
|
|
s.poll(now + Duration::from_millis(500));
|
|
}
|
|
assert_guest_query(&mut s, id, 0, 0);
|
|
assert_eq!(s.release_request(c, id), Err(Error::Busy));
|
|
assert_eq!(s.clear(c, 0), Err(Error::Busy));
|
|
finish_queued_save(lane);
|
|
s.poll(now + Duration::from_millis(501));
|
|
let result = s.query(c, id).unwrap();
|
|
assert_eq!(result.state, RequestState::Failure);
|
|
assert_eq!(result.reason, RequestReason::Timeout);
|
|
assert_eq!(s.request_storage_error(c, id), Ok(Some(Error::Canceled)));
|
|
assert_guest_query(&mut s, id, 2, 15);
|
|
assert!(s.unsaved());
|
|
assert_eq!(reboot(&disk).current().slots[0], before);
|
|
assert_eq!(s.query(c + 1, id), Err(Error::AccessDenied));
|
|
s.release_request(c, id).unwrap();
|
|
assert_eq!(s.query(c, id), Err(Error::InvalidRange));
|
|
s.clear(c, 0).unwrap();
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn lifecycle_cancellation_is_not_a_watchdog_timeout() {
|
|
use super::super::session::{RequestReason, RequestState, Session};
|
|
use std::time::{Duration, Instant};
|
|
for end in [false, true] {
|
|
let (mut card, _) = formatted();
|
|
add(&mut card, 4, 1);
|
|
let mut s = Session::default();
|
|
let c = s.load_card(card, 4, 1, Session::required_bytes(1).unwrap()).unwrap();
|
|
let lane = Arc::new(crate::AsyncWorkLane::default());
|
|
let now = Instant::now();
|
|
let id = s.commit(c, 0, 7, now, &lane).unwrap();
|
|
if end {
|
|
s.end_session();
|
|
} else {
|
|
s.notify_removal();
|
|
}
|
|
s.poll(now + Duration::from_millis(500));
|
|
finish_queued_save(lane);
|
|
s.poll(now + Duration::from_millis(501));
|
|
if end {
|
|
assert_eq!(s.query(c, id), Err(Error::AccessDenied));
|
|
let card = s.take_idle_card().unwrap().unwrap();
|
|
let new = s.load_card(card, 4, 1, Session::required_bytes(1).unwrap()).unwrap();
|
|
assert_ne!(new, c);
|
|
assert_eq!(s.query(new, id), Err(Error::InvalidRange));
|
|
} else {
|
|
assert_eq!(s.query(c, id).unwrap().state, RequestState::Failure);
|
|
assert_eq!(s.query(c, id).unwrap().reason, RequestReason::Storage(Error::Canceled));
|
|
assert_guest_query(&mut s, id, 2, 8);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn deferred_boot_memcard_deadline_stays_timeout() {
|
|
use super::super::session::{RequestReason, Session};
|
|
use std::time::{Duration, Instant};
|
|
let (mut card, _) = formatted();
|
|
add(&mut card, 4, 1);
|
|
let mut s = Session::default();
|
|
let c = s.load_card(card, 4, 1, Session::required_bytes(1).unwrap()).unwrap();
|
|
s.begin_boot();
|
|
let lane = crate::AsyncWorkLane::default();
|
|
let now = Instant::now();
|
|
let id = s.commit(c, 0, 7, now, &lane).unwrap();
|
|
s.poll(now + Duration::from_millis(500));
|
|
assert_eq!(s.query(c, id).unwrap().reason, RequestReason::Timeout);
|
|
assert_guest_query(&mut s, id, 2, 15);
|
|
assert_eq!(lane.pending_depth(), 0);
|
|
s.clear(c, 0).unwrap();
|
|
s.release_request(c, id).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn blocked_host_memcard_watchdog_preserves_outcome_and_escalation() {
|
|
use crate::services::async_work::{
|
|
AsyncWorkLane, AsyncWorkLaneConfig, AsyncWorkLaneController,
|
|
};
|
|
use crate::services::memcard::session::{RequestReason, RequestState, Session};
|
|
use std::time::{Duration, Instant};
|
|
struct Blocked {
|
|
store: Box<dyn MemcardStorage>,
|
|
publication: bool,
|
|
fail_publication: bool,
|
|
entered: std::sync::mpsc::Sender<()>,
|
|
resume: std::sync::mpsc::Receiver<()>,
|
|
}
|
|
impl MemcardStorage for Blocked {
|
|
fn len(&self) -> std::result::Result<u64, MemcardIoError> {
|
|
self.store.len()
|
|
}
|
|
fn read_only(&self) -> bool {
|
|
false
|
|
}
|
|
fn read_at(&mut self, o: u64, b: &mut [u8]) -> std::result::Result<(), MemcardIoError> {
|
|
self.store.read_at(o, b)
|
|
}
|
|
fn sync(&mut self) -> std::result::Result<(), MemcardIoError> {
|
|
self.store.sync()
|
|
}
|
|
fn write_at(&mut self, o: u64, b: &[u8]) -> std::result::Result<(), MemcardIoError> {
|
|
if if self.publication { b.starts_with(b"PMMAP1\0\0") } else { o >= DATA_OFFSET } {
|
|
self.entered.send(()).unwrap();
|
|
self.resume.recv().unwrap();
|
|
if self.fail_publication {
|
|
return Err(MemcardIoError::IoError);
|
|
}
|
|
}
|
|
self.store.write_at(o, b)
|
|
}
|
|
}
|
|
for (publication, fail_publication, escalate, release_early) in [
|
|
(false, false, false, false),
|
|
(true, false, false, false),
|
|
(true, true, false, false),
|
|
(false, false, true, false),
|
|
(true, false, true, false),
|
|
(true, true, true, false),
|
|
(false, false, true, true),
|
|
(true, false, true, true),
|
|
] {
|
|
let (mut card, disk) = formatted();
|
|
add(&mut card, 4, 1);
|
|
let (et, er) = std::sync::mpsc::channel();
|
|
let (rt, rr) = std::sync::mpsc::channel();
|
|
let card = Card::mount(Box::new(Blocked {
|
|
store: card.into_storage(),
|
|
entered: et,
|
|
resume: rr,
|
|
publication,
|
|
fail_publication,
|
|
}))
|
|
.unwrap();
|
|
let mut s = Session::default();
|
|
let c = s.load_card(card, 4, 1, Session::required_bytes(1).unwrap()).unwrap();
|
|
s.write(c, 0, 0, b"pending").unwrap();
|
|
let lane = Arc::new(AsyncWorkLane::default());
|
|
let mut controller =
|
|
AsyncWorkLaneController::start(AsyncWorkLaneConfig::default(), lane.clone());
|
|
let admitted = Instant::now();
|
|
let id = s.commit(c, 0, 7, admitted, &lane).unwrap();
|
|
er.recv_timeout(Duration::from_secs(1)).unwrap();
|
|
s.poll(admitted + Duration::from_millis(500));
|
|
assert_guest_query(&mut s, id, 0, 0);
|
|
let terminal = if escalate {
|
|
s.poll(admitted + Duration::from_secs(1));
|
|
let result = s.query(c, id).unwrap();
|
|
assert_eq!(
|
|
result.state,
|
|
if publication { RequestState::Indeterminate } else { RequestState::Failure }
|
|
);
|
|
assert_eq!(result.reason, RequestReason::RestartRequired);
|
|
assert!(s.host_faulted());
|
|
if release_early {
|
|
s.release_request(c, id).unwrap();
|
|
}
|
|
Some(result)
|
|
} else {
|
|
None
|
|
};
|
|
assert_eq!(s.write(c, 0, 0, b"unsafe"), Err(Error::Busy));
|
|
assert_eq!(s.commit(c, 0, 7, admitted, &lane), Err(Error::Busy));
|
|
rt.send(()).unwrap();
|
|
controller.stop().unwrap();
|
|
s.poll(admitted + Duration::from_millis(if escalate { 1001 } else { 501 }));
|
|
if let Some(terminal) = terminal {
|
|
if release_early {
|
|
assert_eq!(s.query(c, id), Err(Error::InvalidRange));
|
|
} else {
|
|
assert_eq!(s.query(c, id), Ok(terminal));
|
|
assert_guest_query(&mut s, id, if publication { 3 } else { 2 }, 15);
|
|
s.release_request(c, id).unwrap();
|
|
}
|
|
assert!(s.unsaved());
|
|
assert!(s.host_faulted());
|
|
assert_eq!(s.commit(c, 0, 7, admitted, &lane), Err(Error::ReadOnly));
|
|
} else {
|
|
let expected = if fail_publication {
|
|
RequestState::Indeterminate
|
|
} else if publication {
|
|
RequestState::Success
|
|
} else {
|
|
RequestState::Failure
|
|
};
|
|
assert_eq!(s.query(c, id).unwrap().state, expected);
|
|
assert_eq!(s.query(c, id).unwrap().reason, RequestReason::Timeout);
|
|
assert_guest_query(
|
|
&mut s,
|
|
id,
|
|
if fail_publication {
|
|
3
|
|
} else if publication {
|
|
1
|
|
} else {
|
|
2
|
|
},
|
|
15,
|
|
);
|
|
assert_eq!(
|
|
s.request_storage_error(c, id),
|
|
Ok(if fail_publication {
|
|
Some(Error::Io(MemcardIoError::IoError))
|
|
} else if publication {
|
|
None
|
|
} else {
|
|
Some(Error::Canceled)
|
|
})
|
|
);
|
|
assert_eq!(s.unsaved(), expected != RequestState::Success);
|
|
assert_eq!(s.removal_pending(), fail_publication);
|
|
assert!(!s.host_faulted());
|
|
s.release_request(c, id).unwrap();
|
|
}
|
|
let mut durable = reboot(&disk);
|
|
let mut bytes = [0; 7];
|
|
let n = durable.read_slot(0, &mut bytes).unwrap();
|
|
if publication && !fail_publication {
|
|
assert_eq!(&bytes[..n], b"pending");
|
|
} else {
|
|
assert_eq!(n, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
#[test]
|
|
fn file_backend_allocates_full_image_and_reopens_verified_save_without_replacing_files() {
|
|
use prometeu_drivers::memcard::FileMemcard;
|
|
use std::os::unix::fs::MetadataExt;
|
|
let root = std::env::temp_dir().join(format!(
|
|
"prometeu-memcard-{}-{}",
|
|
std::process::id(),
|
|
std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos()
|
|
));
|
|
std::fs::create_dir(&root).unwrap();
|
|
let path = root.join("card.pmc");
|
|
let file = FileMemcard::create(&path, IMAGE_BYTES, |io, id| {
|
|
Card::format(io, id).map_err(|_| MemcardIoError::IoError)
|
|
})
|
|
.unwrap();
|
|
let metadata = std::fs::metadata(&path).unwrap();
|
|
assert_eq!(metadata.len(), IMAGE_BYTES);
|
|
assert!(metadata.blocks() * 512 >= IMAGE_BYTES);
|
|
let mut card = Card::mount(Box::new(file)).unwrap();
|
|
add(&mut card, 1, 1);
|
|
assert_eq!(
|
|
card.commit(0, &vec![17; SLOT_BYTES], 5, &PublicationControl::default()).durable,
|
|
DurableResult::Success
|
|
);
|
|
drop(card);
|
|
assert!(FileMemcard::create(&path, IMAGE_BYTES, |_, _| Ok(())).is_err());
|
|
let mut card = Card::mount(Box::new(FileMemcard::open(&path, true).unwrap())).unwrap();
|
|
let mut out = vec![0; SLOT_BYTES];
|
|
assert_eq!(card.read_slot(0, &mut out), Ok(SLOT_BYTES));
|
|
assert!(out.iter().all(|&b| b == 17));
|
|
assert_eq!(
|
|
card.commit(0, b"no", 6, &PublicationControl::default()).error,
|
|
Some(Error::ReadOnly)
|
|
);
|
|
drop(card);
|
|
std::fs::remove_file(path).unwrap();
|
|
std::fs::remove_dir(root).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn boot_commit_waits_for_ready_and_publishes_registration_before_payload() {
|
|
use crate::services::async_work::{
|
|
AsyncWorkLane, AsyncWorkLaneConfig, AsyncWorkLaneController,
|
|
};
|
|
use crate::services::memcard::session::{RequestState, Session};
|
|
use std::time::{Duration, Instant};
|
|
let (card, d) = formatted();
|
|
let mut s = Session::default();
|
|
let budget = Session::required_bytes(2).unwrap();
|
|
let c = s.prepare_new_card(card, 9, 2, 123, budget).unwrap();
|
|
let icon = [0; 560];
|
|
s.set_presentation(c, "new game", 2, 1, 1, &icon, 124).unwrap();
|
|
s.write(c, 0, 0, b"boot save").unwrap();
|
|
let lane = Arc::new(AsyncWorkLane::default());
|
|
let now = Instant::now();
|
|
let id = s.commit(c, 0, 124, now, &lane).unwrap();
|
|
assert_eq!(lane.pending_depth(), 0);
|
|
assert_eq!(s.query(c, id).unwrap().state, RequestState::Pending);
|
|
assert!(reboot(&d).catalog.games.is_empty());
|
|
s.finish_boot(true, &lane, now).unwrap();
|
|
assert_eq!(lane.pending_depth(), 1);
|
|
let mut controller = AsyncWorkLaneController::start(AsyncWorkLaneConfig::default(), lane);
|
|
let deadline = Instant::now() + Duration::from_secs(2);
|
|
while s.query(c, id).unwrap().state == RequestState::Pending {
|
|
assert!(Instant::now() < deadline);
|
|
s.poll(Instant::now());
|
|
std::thread::yield_now();
|
|
}
|
|
assert_eq!(s.query(c, id).unwrap().state, RequestState::Success);
|
|
assert!(!s.boot_pending());
|
|
assert_eq!(s.boot_error(), None);
|
|
controller.stop().unwrap();
|
|
let mut card = reboot(&d);
|
|
assert_eq!(card.catalog.games[0].created_at, 123);
|
|
let mut b = [0; 16];
|
|
let n = card.read_slot(0, &mut b).unwrap();
|
|
assert_eq!(&b[..n], b"boot save");
|
|
}
|
|
|
|
#[test]
|
|
fn explicit_revalidation_preserves_exclusions_until_separate_reintegration() {
|
|
let (mut card, disk) = formatted();
|
|
add(&mut card, 8, 1);
|
|
card.quarantine(67, &PublicationControl::default()).unwrap();
|
|
card.write_blocked = true;
|
|
card.revalidate(&PublicationControl::default()).unwrap();
|
|
assert!(!card.write_blocked);
|
|
assert!(card.current().quarantine[67]);
|
|
let mut mounted = reboot(&disk);
|
|
assert!(mounted.current().quarantine[67]);
|
|
mounted.reintegrate(67, &PublicationControl::default()).unwrap();
|
|
assert!(!reboot(&disk).current().quarantine[67]);
|
|
}
|
|
|
|
#[test]
|
|
fn reinsertion_retains_ram_and_different_card_requires_explicit_load() {
|
|
use crate::memcard::session::Session;
|
|
let (mut card, source_disk) = formatted();
|
|
add(&mut card, 9, 1);
|
|
card.commit(0, b"on disk", 20, &PublicationControl::default());
|
|
let mut session = Session::default();
|
|
let context = session.load_card(card, 9, 1, 1024 * 1024).unwrap();
|
|
session.clear(context, 0).unwrap();
|
|
session.write(context, 0, 0, b"local").unwrap();
|
|
session
|
|
.replace_storage(Box::new(Store(source_disk)), true, &PublicationControl::default())
|
|
.unwrap();
|
|
let mut bytes = [0; 7];
|
|
assert_eq!(session.read(context, 0, 0, &mut bytes).unwrap(), 5);
|
|
assert_eq!(&bytes[..5], b"local");
|
|
assert!(session.unsaved());
|
|
let other = disk();
|
|
Card::format(&mut Store(other.clone()), [8; 16]).unwrap();
|
|
let mut target = Card::mount(Box::new(Store(other.clone()))).unwrap();
|
|
add(&mut target, 9, 1);
|
|
target.commit(0, b"remote", 30, &PublicationControl::default());
|
|
drop(target);
|
|
session.replace_storage(Box::new(Store(other)), true, &PublicationControl::default()).unwrap();
|
|
assert_eq!(session.read(context, 0, 0, &mut bytes).unwrap(), 6);
|
|
assert_eq!(&bytes[..6], b"remote");
|
|
assert!(!session.unsaved());
|
|
}
|
|
|
|
#[test]
|
|
#[ignore = "manual file-host latency qualification; prints measurements for this host"]
|
|
fn qualify_file_commits_with_production_asset_decoder() {
|
|
use crate::memcard::session::{RequestState, Session};
|
|
use crate::{AsyncWorkLane, AsyncWorkLaneConfig, AsyncWorkLaneController};
|
|
use prometeu_drivers::{AssetManager, MemoryBanks, memcard::FileMemcard};
|
|
use prometeu_hal::{
|
|
AssetBridge,
|
|
asset::{AssetCodec, AssetEntry, BankType},
|
|
cartridge::AssetsPayloadSource,
|
|
};
|
|
use std::time::{Duration, Instant};
|
|
let path = std::env::temp_dir()
|
|
.join(format!("prometeu-memcard-qualification-{}.pmc", std::process::id()));
|
|
let file = FileMemcard::create(&path, IMAGE_BYTES, |io, id| {
|
|
Card::format(io, id).map_err(|_| MemcardIoError::IoError)
|
|
})
|
|
.unwrap();
|
|
struct Timed {
|
|
file: FileMemcard,
|
|
first: Arc<Mutex<Option<Instant>>>,
|
|
}
|
|
impl MemcardStorage for Timed {
|
|
fn len(&self) -> std::result::Result<u64, MemcardIoError> {
|
|
self.file.len()
|
|
}
|
|
fn read_only(&self) -> bool {
|
|
false
|
|
}
|
|
fn read_at(&mut self, o: u64, b: &mut [u8]) -> std::result::Result<(), MemcardIoError> {
|
|
self.file.read_at(o, b)
|
|
}
|
|
fn write_at(&mut self, o: u64, b: &[u8]) -> std::result::Result<(), MemcardIoError> {
|
|
self.first.lock().unwrap().get_or_insert_with(Instant::now);
|
|
self.file.write_at(o, b)
|
|
}
|
|
fn sync(&mut self) -> std::result::Result<(), MemcardIoError> {
|
|
self.file.sync()
|
|
}
|
|
}
|
|
let first = Arc::new(Mutex::new(None));
|
|
let mut card = Card::mount(Box::new(Timed { file, first: first.clone() })).unwrap();
|
|
add(&mut card, 1, 1);
|
|
let mut session = Session::default();
|
|
let context = session.load_card(card, 1, 1, 1024 * 1024).unwrap();
|
|
for offset in (0..SLOT_BYTES).step_by(4096) {
|
|
session.write(context, 0, offset, &[0xa5; 4096]).unwrap();
|
|
}
|
|
let lane = Arc::new(AsyncWorkLane::default());
|
|
let banks = Arc::new(MemoryBanks::new());
|
|
let mut assets = vec![0x12; 512 * 512 / 2];
|
|
assets.extend([255; 64]);
|
|
let entries=(1..=20).map(|id|AssetEntry{asset_id:id,asset_name:format!("glyph-{id}"),bank_type:BankType::GLYPH,
|
|
codec:AssetCodec::None,offset:0,size:assets.len() as u64,decoded_size:512*512+64,
|
|
metadata:serde_json::json!({"tile_size":8,"width":512,"height":512,"palette_count":1,"palette_authored":1})}).collect();
|
|
let mut manager = AssetManager::new(
|
|
entries,
|
|
AssetsPayloadSource::from_bytes(assets),
|
|
banks.clone(),
|
|
banks.clone(),
|
|
banks,
|
|
);
|
|
assert!(manager.bind_background_work(lane.clone()));
|
|
let mut controller =
|
|
AsyncWorkLaneController::start(AsyncWorkLaneConfig::default(), lane.clone());
|
|
let mut times = vec![];
|
|
let mut starts = vec![];
|
|
for sample in 1..=20 {
|
|
let asset = manager.load(sample, 0).unwrap();
|
|
let asset_deadline = Instant::now() + Duration::from_secs(1);
|
|
while matches!(
|
|
manager.status(asset),
|
|
prometeu_hal::asset::LoadStatus::QUEUED | prometeu_hal::asset::LoadStatus::PENDING
|
|
) {
|
|
assert!(Instant::now() < asset_deadline);
|
|
std::thread::yield_now();
|
|
}
|
|
*first.lock().unwrap() = None;
|
|
let start = Instant::now();
|
|
let request = session.commit(context, 0, sample as u64, start, &lane).unwrap();
|
|
loop {
|
|
session.poll(Instant::now());
|
|
if session.query(context, request).unwrap().state != RequestState::Pending {
|
|
break;
|
|
}
|
|
assert!(start.elapsed() < Duration::from_secs(2));
|
|
std::thread::yield_now();
|
|
}
|
|
assert_eq!(session.query(context, request).unwrap().state, RequestState::Success);
|
|
times.push(start.elapsed().as_micros());
|
|
starts.push(first.lock().unwrap().unwrap().duration_since(start).as_micros());
|
|
session.release_request(context, request).unwrap();
|
|
}
|
|
times.sort();
|
|
starts.sort();
|
|
eprintln!(
|
|
"file-host admission-to-first-IO: p50={}us p95={}us max={}us",
|
|
starts[10], starts[18], starts[19]
|
|
);
|
|
eprintln!(
|
|
"file-host 64KiB commit + production asset load: samples={} p50={}us p95={}us max={}us",
|
|
times.len(),
|
|
times[10],
|
|
times[18],
|
|
times[19]
|
|
);
|
|
controller.stop().unwrap();
|
|
drop(session);
|
|
std::fs::remove_file(path).unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn full_card_admission_preserves_card_and_memory_only_can_extend_existing_data() {
|
|
use crate::memcard::{
|
|
MemcardService,
|
|
admission::{Choice, PreparationState},
|
|
session::Mode,
|
|
};
|
|
use crate::{AsyncWorkLaneConfig, AsyncWorkLaneController};
|
|
use std::time::{Duration, Instant};
|
|
let (mut card, _) = formatted();
|
|
add(&mut card, 1, 1);
|
|
add(&mut card, 2, 63);
|
|
card.commit(0, b"prior", 10, &PublicationControl::default());
|
|
let mut service = MemcardService::new();
|
|
let mut controller =
|
|
AsyncWorkLaneController::start(AsyncWorkLaneConfig::default(), service.lane.clone());
|
|
service.mount_card(card.into_storage()).unwrap();
|
|
let wait = |service: &mut MemcardService| {
|
|
let deadline = Instant::now() + Duration::from_secs(2);
|
|
while service.admission.state == PreparationState::Pending {
|
|
service.poll(Instant::now());
|
|
assert!(Instant::now() < deadline);
|
|
std::thread::yield_now();
|
|
}
|
|
};
|
|
wait(&mut service);
|
|
assert_eq!(service.admission.state, PreparationState::Ready);
|
|
assert_eq!(service.choose_for_game(1, 2, Choice::Persistent, 12), Err(Error::NoSpace));
|
|
assert!(service.card_installed());
|
|
service.choose_for_game(1, 2, Choice::MemoryExisting, 12).unwrap();
|
|
wait(&mut service);
|
|
assert_eq!(service.admission.state, PreparationState::Ready);
|
|
let s = &mut service.session;
|
|
let c = s.context();
|
|
assert_eq!(s.mode(), Some(Mode::MemoryOnly));
|
|
let mut bytes = [9; 5];
|
|
assert_eq!(s.read(c, 0, 0, &mut bytes).unwrap(), 5);
|
|
assert_eq!(&bytes, b"prior");
|
|
assert_eq!(s.read(c, 1, 0, &mut bytes).unwrap(), 0);
|
|
s.end_session();
|
|
service.poll(Instant::now());
|
|
assert!(service.card_installed());
|
|
controller.stop().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn ending_a_session_releases_a_completed_unconsumed_request() {
|
|
use crate::memcard::session::{RequestState, Session};
|
|
use crate::{AsyncWorkLane, AsyncWorkLaneConfig, AsyncWorkLaneController};
|
|
use std::time::{Duration, Instant};
|
|
let (mut card, _) = formatted();
|
|
add(&mut card, 1, 1);
|
|
let mut s = Session::default();
|
|
let c = s.load_card(card, 1, 1, 1024 * 1024).unwrap();
|
|
s.write(c, 0, 0, b"saved").unwrap();
|
|
let lane = Arc::new(AsyncWorkLane::default());
|
|
let mut controller =
|
|
AsyncWorkLaneController::start(AsyncWorkLaneConfig::default(), lane.clone());
|
|
let start = Instant::now();
|
|
let id = s.commit(c, 0, 1, start, &lane).unwrap();
|
|
while s.query(c, id).unwrap().state == RequestState::Pending {
|
|
s.poll(Instant::now());
|
|
assert!(start.elapsed() < Duration::from_secs(2));
|
|
std::thread::yield_now();
|
|
}
|
|
s.end_session();
|
|
assert!(!s.has_in_flight());
|
|
assert!(s.take_idle_card().unwrap().is_some());
|
|
controller.stop().unwrap();
|
|
}
|
|
|
|
#[test]
|
|
fn persistent_save_preempts_real_multichunk_asset_decoders() {
|
|
use crate::memcard::session::{RequestState, Session};
|
|
use crate::{AsyncWorkLane, AsyncWorkLaneConfig, AsyncWorkLaneController};
|
|
use prometeu_drivers::{
|
|
AssetManager, GlyphBankPoolAccess, MemoryBanks, SceneBankPoolAccess, SoundBankPoolAccess,
|
|
};
|
|
use prometeu_hal::{
|
|
AssetBridge,
|
|
asset::{AssetCodec, AssetEntry, AssetOpStatus, BankType, LoadStatus},
|
|
background_work::{AssetWork, BackgroundWork, WorkUnavailable},
|
|
cartridge::AssetsPayloadSource,
|
|
};
|
|
use std::{
|
|
sync::mpsc,
|
|
thread,
|
|
time::{Duration, Instant},
|
|
};
|
|
type Events = Arc<Mutex<Vec<(&'static str, thread::ThreadId)>>>;
|
|
struct ObservedLane {
|
|
lane: Arc<AsyncWorkLane>,
|
|
events: Events,
|
|
paused: mpsc::Sender<()>,
|
|
resume: Mutex<Option<mpsc::Receiver<()>>>,
|
|
}
|
|
impl BackgroundWork for ObservedLane {
|
|
fn submit_asset(&self, mut work: AssetWork) -> std::result::Result<(), WorkUnavailable> {
|
|
let events = self.events.clone();
|
|
let paused = self.paused.clone();
|
|
let resume = self.resume.lock().unwrap().take().unwrap();
|
|
let mut step = 0;
|
|
self.lane.submit_asset(Box::new(move |canceled| {
|
|
let result = work(canceled);
|
|
step += 1;
|
|
events.lock().unwrap().push(("asset", thread::current().id()));
|
|
if step == 4 {
|
|
paused.send(()).unwrap();
|
|
resume.recv_timeout(Duration::from_secs(10)).unwrap();
|
|
}
|
|
result
|
|
}))
|
|
}
|
|
}
|
|
struct ObservedStore {
|
|
inner: Store,
|
|
events: Events,
|
|
}
|
|
impl MemcardStorage for ObservedStore {
|
|
fn len(&self) -> std::result::Result<u64, MemcardIoError> {
|
|
self.inner.len()
|
|
}
|
|
fn read_only(&self) -> bool {
|
|
false
|
|
}
|
|
fn read_at(
|
|
&mut self,
|
|
offset: u64,
|
|
out: &mut [u8],
|
|
) -> std::result::Result<(), MemcardIoError> {
|
|
self.inner.read_at(offset, out)
|
|
}
|
|
fn write_at(
|
|
&mut self,
|
|
offset: u64,
|
|
bytes: &[u8],
|
|
) -> std::result::Result<(), MemcardIoError> {
|
|
self.events.lock().unwrap().push(("save write", thread::current().id()));
|
|
self.inner.write_at(offset, bytes)
|
|
}
|
|
fn sync(&mut self) -> std::result::Result<(), MemcardIoError> {
|
|
self.events.lock().unwrap().push(("save sync", thread::current().id()));
|
|
self.inner.sync()
|
|
}
|
|
}
|
|
for kind in [BankType::GLYPH, BankType::SOUNDS, BankType::SCENE] {
|
|
let (card, disk) = formatted();
|
|
drop(card);
|
|
let events: Events = Arc::default();
|
|
let mut card = Card::mount(Box::new(ObservedStore {
|
|
inner: Store(disk.clone()),
|
|
events: events.clone(),
|
|
}))
|
|
.unwrap();
|
|
add(&mut card, 1, 1);
|
|
let mut session = Session::default();
|
|
let context = session.load_card(card, 1, 1, 1024 * 1024).unwrap();
|
|
session.write(context, 0, 0, b"persistent under asset pressure").unwrap();
|
|
events.lock().unwrap().clear();
|
|
let (bytes, decoded_size, metadata) = match kind {
|
|
BankType::GLYPH => {
|
|
let mut bytes = vec![0x12; 16384];
|
|
bytes.extend([255; 64]);
|
|
(
|
|
bytes,
|
|
32768 + 64,
|
|
serde_json::json!({"tile_size":8,"width":256,"height":128,"palette_count":1,"palette_authored":1}),
|
|
)
|
|
}
|
|
BankType::SOUNDS => {
|
|
(vec![0x12; 16385], 16385, serde_json::json!({"sample_rate":44100,"channels":1}))
|
|
}
|
|
BankType::SCENE => {
|
|
let mut bytes = vec![0; 140];
|
|
bytes[..8].copy_from_slice(&[b'S', b'C', b'N', b'E', 1, 0, 4, 0]);
|
|
for start in [12, 44, 76, 108] {
|
|
bytes[start + 5] = 8;
|
|
}
|
|
bytes[12] = 1;
|
|
bytes[28..32].copy_from_slice(&4097_u32.to_le_bytes());
|
|
bytes[32..36].copy_from_slice(&1_u32.to_le_bytes());
|
|
bytes[36..40].copy_from_slice(&4097_u32.to_le_bytes());
|
|
bytes.splice(44..44, std::iter::repeat_n([7, 3, 0x34, 0x12], 4097).flatten());
|
|
(
|
|
bytes,
|
|
64 + 4097 * size_of::<prometeu_hal::tile::Tile>() as u64,
|
|
serde_json::json!({}),
|
|
)
|
|
}
|
|
};
|
|
let entry = AssetEntry {
|
|
asset_id: 1,
|
|
asset_name: "pressure".into(),
|
|
bank_type: kind,
|
|
offset: 0,
|
|
size: bytes.len() as u64,
|
|
decoded_size,
|
|
codec: AssetCodec::None,
|
|
metadata,
|
|
};
|
|
let banks = Arc::new(MemoryBanks::new());
|
|
let mut manager = AssetManager::new(
|
|
vec![entry],
|
|
AssetsPayloadSource::from_bytes(bytes),
|
|
banks.clone(),
|
|
banks.clone(),
|
|
banks.clone(),
|
|
);
|
|
let lane = Arc::new(AsyncWorkLane::default());
|
|
let (paused_tx, paused_rx) = mpsc::channel();
|
|
let (resume_tx, resume_rx) = mpsc::channel();
|
|
let observed = Arc::new(ObservedLane {
|
|
lane: lane.clone(),
|
|
events: events.clone(),
|
|
paused: paused_tx,
|
|
resume: Mutex::new(Some(resume_rx)),
|
|
});
|
|
assert!(manager.bind_background_work(observed));
|
|
let mut controller =
|
|
AsyncWorkLaneController::start(AsyncWorkLaneConfig::default(), lane.clone());
|
|
let handle = manager.load(1, 0).unwrap();
|
|
paused_rx.recv_timeout(Duration::from_secs(10)).unwrap();
|
|
assert_eq!(manager.status(handle), LoadStatus::LOADING);
|
|
assert!(
|
|
banks.glyph_bank_slot(0).is_none()
|
|
&& banks.sound_bank_slot(0).is_none()
|
|
&& banks.scene_bank_slot(0).is_none()
|
|
);
|
|
let request = session.commit(context, 0, 7, Instant::now(), &lane).unwrap();
|
|
resume_tx.send(()).unwrap();
|
|
let deadline = Instant::now() + Duration::from_secs(10);
|
|
loop {
|
|
session.poll(Instant::now());
|
|
if session.query(context, request).unwrap().state != RequestState::Pending
|
|
&& manager.status(handle) == LoadStatus::READY
|
|
{
|
|
break;
|
|
}
|
|
assert!(Instant::now() < deadline, "save/asset did not complete for {kind:?}");
|
|
thread::yield_now();
|
|
}
|
|
assert_eq!(session.query(context, request).unwrap().state, RequestState::Success);
|
|
assert!(
|
|
banks.glyph_bank_slot(0).is_none()
|
|
&& banks.sound_bank_slot(0).is_none()
|
|
&& banks.scene_bank_slot(0).is_none()
|
|
);
|
|
assert_eq!(manager.commit(handle), AssetOpStatus::Ok);
|
|
manager.apply_commits();
|
|
match kind {
|
|
BankType::GLYPH => {
|
|
let bank = banks.glyph_bank_slot(0).unwrap();
|
|
assert_eq!((bank.width, bank.height), (256, 128));
|
|
assert_eq!(
|
|
bank.pixel_indices,
|
|
(0..32768).map(|i| 1 + (i % 2) as u8).collect::<Vec<_>>()
|
|
);
|
|
assert!(bank.palettes[0].iter().all(|c| c.raw() == 0xffffffff));
|
|
}
|
|
BankType::SOUNDS => {
|
|
let bank = banks.sound_bank_slot(0).unwrap();
|
|
assert_eq!(bank.samples[0].sample_rate, 44100);
|
|
assert_eq!(bank.samples[0].data, vec![0x1212; 8192]);
|
|
}
|
|
BankType::SCENE => {
|
|
let bank = banks.scene_bank_slot(0).unwrap();
|
|
assert_eq!(
|
|
(bank.layers[0].tilemap.width, bank.layers[0].tilemap.height),
|
|
(4097, 1)
|
|
);
|
|
assert!(bank.layers[0].active);
|
|
assert_eq!(bank.layers[0].tilemap.tiles.len(), 4097);
|
|
assert!(bank.layers[0].tilemap.tiles.iter().all(|t| t.active
|
|
&& t.flip_x
|
|
&& t.flip_y
|
|
&& t.glyph.glyph_id == 0x1234
|
|
&& t.glyph.palette_id == 3));
|
|
assert!(bank.layers[1..].iter().all(|l| l.tilemap.tiles.is_empty()));
|
|
}
|
|
}
|
|
controller.stop().unwrap();
|
|
let observed = events.lock().unwrap();
|
|
assert_eq!(observed[..4].iter().map(|e| e.0).collect::<Vec<_>>(), vec!["asset"; 4]);
|
|
assert_eq!(observed[4].0, "save write");
|
|
let resumed = observed[4..].iter().position(|e| e.0 == "asset").unwrap() + 4;
|
|
assert_eq!(observed[resumed - 1].0, "save sync");
|
|
assert!(observed[resumed..].iter().all(|e| e.0 == "asset"));
|
|
let worker = observed[0].1;
|
|
assert_ne!(worker, thread::current().id());
|
|
assert!(observed.iter().all(|e| e.1 == worker));
|
|
drop(observed);
|
|
drop(session);
|
|
let mut recovered = Session::default();
|
|
let c = recovered.load_card(reboot(&disk), 1, 1, 1024 * 1024).unwrap();
|
|
let mut saved = [0; 64];
|
|
let n = recovered.read(c, 0, 0, &mut saved).unwrap();
|
|
assert_eq!(&saved[..n], b"persistent under asset pressure");
|
|
}
|
|
}
|