//! M2 presentation and a single blocking worker. No mod file operations live here.
use crate::{ModsWindow, bindings, catalogue::CatalogueController, controller::Controller};
use fmm_core::install::TRASH_NAME;
use fmm_core::{
Result,
cache::Cache,
download,
install::{self, Plan, Report},
local_mods::{BUILTIN_ORDER, LocalMod, ModSource},
net::Http,
portal::PortalModFull,
portal_data::PortalData,
store::{self, Snapshot},
};
use slint::{ComponentHandle, ModelRc, VecModel};
use std::{cell::RefCell, collections::HashMap, rc::Rc, sync::mpsc};
pub fn action(name: &str, local: &[LocalMod], outdated: bool) -> i32 {
if BUILTIN_ORDER.contains(&name)
|| local
.iter()
.any(|m| m.name == name && m.source == ModSource::Builtin)
{
0
} else if !local.iter().any(|m| m.name == name) {
1
} else if outdated {
2
} else {
3
}
}
#[derive(Default, Debug, PartialEq, Eq)]
pub struct Dialog {
pub title: String,
pub lines: Vec<String>,
pub confirm: bool,
}
pub fn dialog(plan: &Plan, roots: &[String], remove: bool) -> Dialog {
let mut lines = vec![];
let mut also = vec![];
let mut updates = vec![];
for a in plan.actions() {
if let Some(r) = &a.release {
let label = format!("{} {}", a.name, r.version);
if !a.previous.is_empty() {
updates.push(label);
} else if roots.contains(&a.name) {
lines.push(format!("Install {label}"));
} else {
also.push(label);
}
} else {
lines.push(format!(
"Move {} to the {TRASH_NAME}? The game will no longer load it.",
a.name
));
}
}
if !also.is_empty() {
lines.push(format!("Also installs: {}", also.join(", ")));
}
if !updates.is_empty() {
lines.push(format!("Updates: {}", updates.join(", ")));
}
if !plan.optional().is_empty() {
lines.push(format!(
"Optional dependencies (not downloaded): {}",
plan.optional().join(", ")
));
}
lines.extend(plan.warnings().iter().map(|s| format!("Warning: {s}")));
lines.extend(
plan.failures()
.iter()
.map(|f| format!("Failed: {}: {}", f.name, f.message)),
);
if lines.is_empty() {
lines.push("Already up to date".into());
}
Dialog {
title: if remove {
"Remove mod"
} else {
"Confirm installation"
}
.into(),
lines,
confirm: !plan.actions().is_empty(),
}
}
pub fn skip_dialog(plan: &Plan) -> bool {
plan.actions().len() == 1
&& plan.actions()[0].release.is_some()
&& !plan.actions()[0].previous.is_empty()
&& plan.failures().is_empty()
}
pub fn show_dialog(app: &ModsWindow, d: Dialog) {
app.set_operation_title(d.title.into());
app.set_operation_lines(ModelRc::new(VecModel::from(
d.lines.into_iter().map(Into::into).collect::<Vec<_>>(),
)));
app.set_operation_confirmable(d.confirm);
app.set_operation_dialog(true);
}
pub fn save_installed(
cache: &Cache,
store: &fmm_core::metadata::MetadataStore,
report: &Report,
versions: &[(String, String)],
full: &HashMap<String, PortalModFull>,
) -> Vec<String> {
let data = PortalData {
fetcher: Http::default(),
cache: cache.clone(),
};
let mut errors = vec![];
for outcome in report.mods.iter().filter(|o| o.ok) {
let Some((_, version)) = versions.iter().find(|(n, _)| n == &outcome.name) else {
continue;
};
let Some(metadata) = full.get(&outcome.name) else {
continue;
};
if let Err(e) = store.retain(&data, metadata, version) {
errors.push(format!("{} metadata: {e}", outcome.name));
}
}
errors
}
enum Message {
Planned {
plan: Box<Plan>,
full: HashMap<String, PortalModFull>,
roots: Vec<String>,
remove: bool,
review_dependencies: bool,
},
Progress(String, download::Progress),
Finished(
Report,
Box<std::result::Result<Snapshot, String>>,
Vec<String>,
),
Failed(String),
Cleaned,
/// Another program changed the mods folder.
Changed,
Rescanned(Box<std::result::Result<Snapshot, String>>),
ManageChangelog(
String,
u64,
std::result::Result<fmm_core::changelog::Changelog, String>,
),
}
/// Reuse the exact paths that were planned or loaded; never rediscover a different mods directory.
fn rescan(snapshot: Snapshot, cache: &Cache) -> Result<Snapshot> {
let scan = fmm_core::local_mods::scan_mods_dir(
&snapshot.paths.mods_dir,
Some(&cache.path("thumbs")?),
)?;
Ok(Snapshot {
mods: scan.mods,
scan_errors: scan.errors,
mod_list: fmm_core::mod_list::read_mod_list(&snapshot.paths.mod_list_path)?,
..snapshot
})
}
fn send(tx: &mpsc::Sender<Message>, weak: &slint::Weak<ModsWindow>, message: Message) {
if tx.send(message).is_ok() {
let weak = weak.clone();
let _ = slint::invoke_from_event_loop(move || {
if let Some(app) = weak.upgrade() {
app.invoke_operation_event();
}
});
}
}
struct Runtime {
manage: Rc<RefCell<Controller>>,
catalogue: Rc<RefCell<CatalogueController>>,
cache: Cache,
tx: mpsc::Sender<Message>,
rx: mpsc::Receiver<Message>,
pending: Option<(Plan, HashMap<String, PortalModFull>)>,
queue: install::DownloadQueue,
busy: bool,
cleaned: bool,
/// An outside change arrived while an operation or rescan was running.
dirty: bool,
rescanning: bool,
watcher: Option<notify::RecommendedWatcher>,
}
impl Runtime {
fn begin_request(&mut self, app: &ModsWindow, names: &[String]) -> bool {
if self.busy || names.is_empty() {
return false;
}
self.busy = true;
app.set_batch_busy(true);
app.set_results_banner("".into());
app.set_batch_status("Preparing plan…".into());
true
}
fn request(&mut self, app: &ModsWindow, names: Vec<String>, remove: bool, updates: bool) {
self.request_with_dependencies(app, names, remove, updates, vec![]);
}
fn request_with_dependencies(
&mut self,
app: &ModsWindow,
names: Vec<String>,
remove: bool,
updates: bool,
requirements: Vec<fmm_core::version::Dependency>,
) {
if !self.begin_request(app, &names) {
return;
}
let snapshot = self.manage.borrow().snapshot.clone();
let cache = self.cache.clone();
let tx = self.tx.clone();
let weak = app.as_weak();
let clean = !self.cleaned;
// Startup cleanup is completed once, before the first batch, if startup found the game running.
std::thread::spawn(move || {
if clean && !store::is_factorio_running() {
match download::clean_temp_for(&snapshot.paths) {
Ok(_) => send(&tx, &weak, Message::Cleaned),
Err(e) if e.to_string() == store::RUNNING_MESSAGE => {}
Err(e) => {
send(
&tx,
&weak,
Message::Failed(format!("Temporary download cleanup failed: {e}")),
);
return;
}
}
}
let data = PortalData {
fetcher: Http::default(),
cache,
};
let full = RefCell::new(HashMap::new());
let lookup = |name: &str| {
let metadata = data.full(name)?;
full.borrow_mut().insert(name.to_owned(), metadata.clone());
Ok(metadata)
};
let plan = if !requirements.is_empty() {
install::plan_dependencies(
&requirements,
&snapshot,
&lookup,
&snapshot.paths.game_version,
)
} else if remove {
install::plan_remove(&names, &snapshot)
} else if updates {
install::plan_updates_selected(
&names,
&snapshot,
&lookup,
&snapshot.paths.game_version,
)
} else {
install::plan_install(&names, &snapshot, &lookup, &snapshot.paths.game_version)
};
send(
&tx,
&weak,
Message::Planned {
plan: Box::new(plan),
full: full.into_inner(),
roots: names,
remove,
review_dependencies: !requirements.is_empty(),
},
);
});
}
fn show_queue(&mut self, app: &ModsWindow, plan: &Plan, full: &HashMap<String, PortalModFull>) {
self.queue = install::DownloadQueue::new(plan);
{
let mut manage = self.manage.borrow_mut();
manage
.downloads
.retain(|r| !plan.actions().iter().any(|a| a.name == r.name));
manage
.downloads
.extend(plan.actions().iter().filter_map(|a| {
a.release.as_ref().map(|r| crate::model::Row {
name: a.name.clone(),
title: full
.get(&a.name)
.map_or_else(|| a.name.clone(), |f| f.mod_.title.clone()),
version: r.version.clone(),
locked: true,
dimmed: true,
placeholder: true,
download: true,
progress_label: "Queued".into(),
..Default::default()
})
}));
bindings::publish(app, manage.model(), &manage.error);
}
}
fn cancel_download(&self, app: &ModsWindow, name: &str) {
self.queue.cancel(name);
let mut manage = self.manage.borrow_mut();
manage.downloads.retain(|row| row.name != name);
self.catalogue.borrow_mut().progress.remove(name);
if app.get_download_name() == name {
app.set_download_name("".into());
}
bindings::publish(app, manage.model(), &manage.error);
self.catalogue.borrow().publish(app);
}
fn execute(&mut self, app: &ModsWindow) {
let Some((plan, full)) = self.pending.take() else {
return;
};
let verify_sha1 = app.get_verify_downloads();
app.set_operation_dialog(false);
app.set_batch_status("Downloading and verifying mods…".into());
let tx = self.tx.clone();
let weak = app.as_weak();
self.show_queue(app, &plan, &full);
let queue = self.queue.clone();
let cache = self.cache.clone();
let snapshot = self.manage.borrow().snapshot.clone();
std::thread::spawn(move || {
let mut last = std::time::Instant::now() - std::time::Duration::from_secs(1);
let report = install::run_queue_with_checks(
&plan,
&Http::default(),
&mut |name, p| {
if p.bytes == 0
|| p.total == Some(p.bytes)
|| last.elapsed() >= std::time::Duration::from_millis(60)
{
last = std::time::Instant::now();
send(&tx, &weak, Message::Progress(name.into(), p));
}
},
&queue,
&store::is_factorio_running,
&install::Disk,
verify_sha1,
);
let versions = plan
.actions()
.iter()
.filter_map(|a| {
a.release
.as_ref()
.map(|r| (a.name.clone(), r.version.clone()))
})
.collect::<Vec<_>>();
let errors = match fmm_core::metadata::app_metadata_dir() {
Ok(root) => {
let store = fmm_core::metadata::MetadataStore::new(root);
let errors = save_installed(&cache, &store, &report, &versions, &full);
let data = PortalData {
fetcher: Http::default(),
cache: cache.clone(),
};
for outcome in report
.mods
.iter()
.filter(|o| o.ok && versions.iter().any(|(n, _)| n == &o.name))
{
if let Some(f) = full.get(&outcome.name)
&& let Err(e) = store.retain_thumbnail(&data, f)
{
eprintln!("Metadata thumbnail: {e}");
}
}
errors
}
Err(e) => vec![format!("Metadata store: {e}")],
};
let rescan = rescan(snapshot, &cache);
send(
&tx,
&weak,
Message::Finished(report, Box::new(rescan.map_err(|e| e.to_string())), errors),
);
});
}
fn idle(&mut self, app: &ModsWindow) {
self.catalogue.borrow_mut().progress.clear();
self.catalogue.borrow().publish(app);
self.busy = false;
self.pending = None;
app.set_batch_busy(false);
app.set_download_name("".into());
app.set_batch_status("".into());
self.rescan_external(app);
}
/// Operations rescan their own result, so outside changes wait until the runtime is idle.
fn rescan_external(&mut self, app: &ModsWindow) {
if !self.dirty || self.busy || self.rescanning {
return;
}
self.dirty = false;
self.rescanning = true;
let snapshot = self.manage.borrow().snapshot.clone();
let cache = self.cache.clone();
let tx = self.tx.clone();
let weak = app.as_weak();
std::thread::spawn(move || {
let result = rescan(snapshot, &cache).map_err(|e| e.to_string());
send(&tx, &weak, Message::Rescanned(Box::new(result)));
});
}
/// Adopt a fresh scan, keeping still-valid pending toggles, pins and selection.
fn adopt(&mut self, app: &ModsWindow, snapshot: Snapshot) -> Vec<String> {
let mut notes = Vec::new();
self.catalogue.borrow_mut().rescan(&snapshot);
let mut c = self.manage.borrow_mut();
c.snapshot = snapshot;
let pins = std::mem::take(&mut c.pins);
for (name, choice) in pins {
if let Ok(next) = fmm_core::enable::set_pin(&c.snapshot, &c.pins, &name, choice) {
c.pins = next;
} else {
notes.push(format!("Cleared unavailable version pin for {name}"));
}
}
let pending = std::mem::take(&mut c.pending);
for (name, value) in pending {
if !c
.snapshot
.mods
.iter()
.chain(&c.snapshot.builtin)
.any(|m| m.name == name)
{
continue;
}
c.pending = fmm_core::enable::set_pending(&c.snapshot, &c.pending, &name, value);
}
let selection = c.selection.take();
c.changelog = Default::default();
if let Some(name) = selection.filter(|n| {
c.snapshot
.mods
.iter()
.chain(&c.snapshot.builtin)
.any(|m| &m.name == n)
}) {
c.select(&name);
}
bindings::publish(app, c.model(), &c.error);
notes
}
fn drain(&mut self, app: &ModsWindow) {
while let Ok(message) = self.rx.try_recv() {
match message {
Message::Cleaned => self.cleaned = true,
Message::Changed => {
self.dirty = true;
self.rescan_external(app);
}
Message::Rescanned(result) => {
self.rescanning = false;
if self.busy {
// The running operation rescans its own result; look again once idle.
self.dirty = true;
continue;
}
match *result {
Ok(snapshot) => {
let notes = self.adopt(app, snapshot);
self.catalogue.borrow().publish(app);
if !notes.is_empty() {
app.set_results_banner(notes.join("; ").into());
}
}
Err(e) => app.set_results_banner(format!("Rescan failed: {e}").into()),
}
self.rescan_external(app);
}
Message::ManageChangelog(name, revision, result) => {
let mut c = self.manage.borrow_mut();
if c.selection.as_deref() == Some(&name) && c.changelog_revision == revision {
c.notice.clear();
match result {
Ok(log) => c.changelog = log,
Err(e) => {
c.changelog = Default::default();
c.notice = format!("Portal changelog unavailable: {e}");
}
}
c.view.show_changelog = true;
bindings::publish(app, c.model(), &c.error);
}
}
Message::Failed(e) => {
crate::audio::cannot(app);
self.idle(app);
app.set_results_banner(e.into());
}
Message::Planned {
plan,
full,
roots,
remove,
review_dependencies,
} => {
self.catalogue.borrow_mut().full.extend(full.clone());
if !plan.failures().is_empty() {
crate::audio::cannot(app);
}
let d = dialog(&plan, &roots, remove);
let skip = !remove && !review_dependencies && skip_dialog(&plan);
if skip {
let notes = plan
.warnings()
.iter()
.cloned()
.chain(
plan.optional()
.iter()
.map(|s| format!("Optional dependency (not downloaded): {s}")),
)
.collect::<Vec<_>>();
app.set_results_banner(notes.join("; ").into());
}
self.pending = Some((*plan, full));
if skip {
self.execute(app);
} else {
app.set_batch_status("Review the plan".into());
show_dialog(app, d);
}
}
Message::Progress(name, p) => {
if self.queue.cancelled(&name) {
continue;
}
app.set_download_name(name.clone().into());
app.set_download_fraction(
p.total
.filter(|n| *n > 0)
.map_or(0.0, |n| p.bytes as f32 / n as f32),
);
self.catalogue
.borrow_mut()
.progress
.insert(name.clone(), app.get_download_fraction());
self.catalogue.borrow().publish(app);
let bytes = p.total.map_or_else(
|| format!("{} bytes", p.bytes),
|n| format!("{} / {} bytes", p.bytes, n),
);
app.set_download_label(
if p.total.is_some() {
format!("{}%", (app.get_download_fraction() * 100.0) as u32)
} else {
"Downloading…".into()
}
.into(),
);
{
let mut manage = self.manage.borrow_mut();
if let Some(row) = manage.downloads.iter_mut().find(|r| r.name == name) {
row.fraction = app.get_download_fraction();
row.progress_label = app.get_download_label().to_string();
}
bindings::publish(app, manage.model(), &manage.error);
}
app.set_batch_status(
format!(
"Downloading {name}: {bytes}{}",
if p.retry > 0 {
format!(" (retry {})", p.retry)
} else {
String::new()
}
)
.into(),
);
}
Message::Finished(report, snapshot, errors) => {
if report
.mods
.iter()
.any(|m| !m.ok && !self.queue.cancelled(&m.name))
{
crate::audio::cannot(app);
}
{
let mut manage = self.manage.borrow_mut();
manage.downloads.retain_mut(|row| {
if self.queue.cancelled(&row.name) {
return false;
}
if let Some(outcome) = report.mods.iter().find(|o| o.name == row.name) {
if outcome.ok {
return false;
}
row.download = false;
row.failed = true;
row.progress_label = outcome.message.clone();
row.tooltip = outcome.message.clone();
}
true
});
}
let mut summary = report.summary();
if !errors.is_empty() {
summary.push_str(&format!("; {}", errors.join("; ")));
}
match *snapshot {
Ok(snapshot) => {
for note in self.adopt(app, snapshot) {
summary.push_str(&format!("; {note}"));
}
}
Err(e) => summary.push_str(&format!("; Rescan failed: {e}")),
}
self.idle(app);
self.catalogue.borrow().publish(app);
app.set_results_banner(summary.into());
}
}
}
}
}
pub fn bind(
app: &ModsWindow,
manage: Rc<RefCell<Controller>>,
catalogue: Rc<RefCell<CatalogueController>>,
cache: Cache,
cleaned: bool,
) {
let weak = app.as_weak();
app.window().on_close_requested(move || {
if weak.upgrade().is_some_and(|app| app.get_batch_busy()) {
slint::CloseRequestResponse::KeepWindowShown
} else {
if let Some(app) = weak.upgrade() {
app.global::<crate::UiSounds>()
.invoke_finish(crate::UiCue::Tool);
}
slint::CloseRequestResponse::HideWindow
}
});
let (tx, rx) = mpsc::channel();
let state = Rc::new(RefCell::new(Runtime {
manage,
catalogue,
cache,
tx,
rx,
pending: None,
queue: Default::default(),
busy: false,
cleaned,
dirty: false,
rescanning: false,
watcher: None,
}));
let mods_dir = state
.borrow()
.manage
.borrow()
.snapshot
.paths
.mods_dir
.clone();
if !mods_dir.as_os_str().is_empty() {
let tx = state.borrow().tx.clone();
let weak = app.as_weak();
match crate::watch::spawn(mods_dir, move || send(&tx, &weak, Message::Changed)) {
Ok(watcher) => state.borrow_mut().watcher = Some(watcher),
Err(e) => eprintln!("Mods folder changes won't refresh automatically: {e}"),
}
}
let s = state.clone();
let weak = app.as_weak();
app.on_install_missing(move || {
if let Some(app) = weak.upgrade() {
let runtime = s.borrow();
let c = runtime.manage.borrow();
let requirements = c.missing_dependencies();
let names: Vec<_> = requirements.iter().map(|d| d.name.clone()).collect();
drop(c);
drop(runtime);
s.borrow_mut()
.request_with_dependencies(&app, names, false, false, requirements);
}
});
let s = state.clone();
let weak = app.as_weak();
app.on_open_changelog(move || {
let Some(app) = weak.upgrade() else {
return;
};
let runtime = s.borrow();
let mut c = runtime.manage.borrow_mut();
if !c.changelog.releases.is_empty() {
c.open_changelog();
bindings::publish(&app, c.model(), &c.error);
return;
}
let Some(name) = c.selection.clone() else {
return;
};
let revision = c.changelog_revision;
c.notice = "Loading changelog…".into();
bindings::publish(&app, c.model(), &c.error);
let cache = runtime.cache.clone();
let tx = runtime.tx.clone();
let weak = app.as_weak();
std::thread::spawn(move || {
let data = PortalData {
fetcher: Http::default(),
cache,
};
let log = data
.full(&name)
.map(|f| fmm_core::changelog::parse(f.changelog.as_deref().unwrap_or_default()))
.map_err(|e| e.to_string());
send(&tx, &weak, Message::ManageChangelog(name, revision, log));
});
});
let s = state.clone();
let weak = app.as_weak();
app.on_mod_action(move |name, remove| {
if let Some(app) = weak.upgrade() {
s.borrow_mut()
.request(&app, vec![name.to_string()], remove, false);
}
});
let s = state.clone();
let weak = app.as_weak();
app.on_update_selected(move || {
if let Some(app) = weak.upgrade() {
let names = s.borrow().catalogue.borrow().selected_updates();
s.borrow_mut().request(&app, names, false, true);
}
});
let s = state.clone();
let weak = app.as_weak();
app.on_operation_accept(move || {
if let Some(app) = weak.upgrade()
&& app.get_operation_confirmable()
{
s.borrow_mut().execute(&app);
}
});
let s = state.clone();
let weak = app.as_weak();
app.on_operation_back(move || {
if let Some(app) = weak.upgrade() {
app.set_operation_dialog(false);
s.borrow_mut().idle(&app);
}
});
let s = state.clone();
let weak = app.as_weak();
app.on_download_cancel(move |name| {
if let Some(app) = weak.upgrade() {
s.borrow().cancel_download(&app, &name);
}
});
let weak = app.as_weak();
app.on_operation_event(move || {
if let Some(app) = weak.upgrade() {
state.borrow_mut().drain(&app);
}
});
}
#[cfg(test)]
pub fn check_worker_messages(app: &ModsWindow, snapshot: Snapshot, cache: Cache) {
let mut full: PortalModFull = serde_json::from_value(serde_json::json!({
"name":"new", "title":"New mod", "releases":[{"version":"1.0.0", "sha1":"1111111111111111111111111111111111111111", "info_json":{"factorio_version":"2.0", "dependencies":["base"]}}]
})).unwrap();
full.mod_.latest_release = full.mod_.releases.as_ref().and_then(|r| r.first()).cloned();
let catalogue = Rc::new(RefCell::new(CatalogueController::new(&snapshot)));
catalogue
.borrow_mut()
.set_catalogue(Some(fmm_core::explore::ExploreIndex::new(
vec![full.mod_.clone()],
"2.0",
)));
let manage = Rc::new(RefCell::new(Controller::new(snapshot.clone())));
let (tx, rx) = mpsc::channel();
let mut runtime = Runtime {
manage: manage.clone(),
catalogue: catalogue.clone(),
cache,
tx: tx.clone(),
rx,
pending: None,
queue: Default::default(),
busy: true,
cleaned: false,
dirty: false,
rescanning: false,
watcher: None,
};
// A second request cannot spawn a worker or replace the first batch's cancellation token.
let roots = vec!["new".into()];
let plan = install::plan_install(&roots, &snapshot, &|_| Ok(full.clone()), "2.0");
runtime.queue = install::DownloadQueue::new(&plan);
runtime.queue.cancel("new");
runtime.request(app, vec!["new".into()], false, false);
assert!(runtime.queue.cancelled("new"));
runtime.queue = Default::default();
let roots = vec!["new".into()];
let plan = install::plan_install(&roots, &snapshot, &|_| Ok(full.clone()), "2.0");
tx.send(Message::Planned {
plan: Box::new(plan),
full: [("new".into(), full)].into_iter().collect(),
roots,
remove: false,
review_dependencies: false,
})
.unwrap();
runtime.drain(app);
assert!(
!runtime.cleaned,
"a skipped cleanup remains pending after planning"
);
tx.send(Message::Cleaned).unwrap();
runtime.drain(app);
assert!(runtime.cleaned);
let (plan, full) = runtime.pending.as_ref().unwrap().clone();
runtime.show_queue(app, &plan, &full);
use slint::Model;
let queued = app.get_rows().iter().find(|r| r.name == "new").unwrap();
assert!(queued.placeholder && queued.download && !queued.checked);
assert_eq!(queued.progress_label, "Queued");
assert_eq!(queued.title, "New mod");
assert!(app.get_operation_dialog());
assert!(app.get_operation_confirmable());
assert_eq!(app.get_operation_title(), "Confirm installation");
let tx_worker = tx.clone();
std::thread::spawn(move || {
tx_worker
.send(Message::Progress(
"new".into(),
download::Progress {
bytes: 40,
total: Some(100),
retry: 1,
},
))
.unwrap()
})
.join()
.unwrap();
runtime.drain(app);
assert_eq!(app.get_download_name(), "new");
assert_eq!(app.get_download_fraction(), 0.4);
assert!(app.get_batch_status().contains("retry 1"));
assert_eq!(
app.get_rows()
.iter()
.find(|r| r.name == "new")
.unwrap()
.fraction,
0.4
);
let mut after = snapshot;
manage.borrow_mut().downloads.push(crate::model::Row {
name: "bad".into(),
title: "Failed download".into(),
placeholder: true,
download: true,
locked: true,
dimmed: true,
..Default::default()
});
let mut installed = after.mods[0].clone();
installed.name = "new".into();
installed.version = "1.0.0".into();
installed.source = ModSource::Zip;
after.mods.push(installed);
manage.borrow_mut().pending.push(("a".into(), true));
manage
.borrow_mut()
.pins
.push(("z".into(), Some("2.0.77".into())));
tx.send(Message::Finished(
Report {
mods: vec![
install::Outcome {
name: "new".into(),
ok: true,
message: "Installed".into(),
},
install::Outcome {
name: "bad".into(),
ok: false,
message: "Not on the mirror yet".into(),
},
],
},
Box::new(Ok(after)),
vec![],
))
.unwrap();
runtime.drain(app);
assert!(!runtime.busy);
assert!(
!app.get_rows()
.iter()
.find(|r| r.name == "new")
.unwrap()
.placeholder
);
let failed = app.get_rows().iter().find(|r| r.name == "bad").unwrap();
assert!(failed.failed && failed.placeholder && !failed.download);
assert_eq!(failed.progress_label, "Not on the mirror yet");
runtime.cancel_download(app, "bad");
assert!(!app.get_rows().iter().any(|r| r.name == "bad"));
assert_eq!(
manage.borrow().pending,
vec![("a".into(), true)],
"Install missing preserves unsaved toggles across rescan"
);
assert_eq!(manage.borrow().pins, [("z".into(), Some("2.0.77".into()))]);
assert!(runtime.pending.is_none());
assert!(app.get_download_name().is_empty());
assert!(app.get_batch_status().is_empty());
assert!(app.get_results_banner().contains("1 failed: bad:"));
assert!(
manage
.borrow()
.snapshot
.mods
.iter()
.any(|m| m.name == "new")
);
assert!(
app.get_explore_rows()
.iter()
.find(|m| m.name == "new")
.unwrap()
.installed
);
assert_eq!(app.get_explore_rows().row_data(0).unwrap().action, 3);
tx.send(Message::Failed(store::RUNNING_MESSAGE.into()))
.unwrap();
runtime.drain(app);
assert_eq!(app.get_results_banner(), store::RUNNING_MESSAGE);
assert!(!app.get_batch_busy());
manage.borrow_mut().pending.push(("a".into(), true));
assert!(runtime.begin_request(app, &["new".into()]));
assert!(runtime.busy, "pending choices do not block a new operation");
runtime.idle(app);
let name = manage.borrow().selection.clone().unwrap();
let revision = manage.borrow().changelog_revision;
let portal_log =
fmm_core::changelog::parse("Version: 1.0.0\n Features:\n - Portal fallback\n");
tx.send(Message::ManageChangelog(
name.clone(),
revision,
Ok(portal_log.clone()),
))
.unwrap();
runtime.drain(app);
assert!(app.get_show_changelog());
assert!(app.get_changelog_text().contains("Portal fallback"));
manage.borrow_mut().notice = "Loading changelog…".into();
manage.borrow_mut().select("a");
assert!(manage.borrow().notice.is_empty());
tx.send(Message::ManageChangelog(
name,
revision,
Ok(portal_log.clone()),
))
.unwrap();
runtime.drain(app);
assert!(
manage.borrow().changelog.releases.is_empty(),
"old selection response is ignored"
);
tx.send(Message::ManageChangelog(
"a".into(),
manage.borrow().changelog_revision,
Ok(Default::default()),
))
.unwrap();
runtime.drain(app);
assert_eq!(app.get_changelog_text(), "No changelog");
app.set_show_changelog(false);
// The selection can be the same name again after a pin change or Undo.
manage.borrow_mut().undo();
tx.send(Message::ManageChangelog(
"a".into(),
revision,
Ok(portal_log),
))
.unwrap();
runtime.drain(app);
assert!(!app.get_show_changelog());
assert!(manage.borrow().changelog.releases.is_empty());
// A dependency repair that only updates one mod must still be reviewed.
let snapshot = manage.borrow().snapshot.clone();
let full: PortalModFull = serde_json::from_value(serde_json::json!({
"name":"a", "releases":[{"version":"3.0.0", "sha1":"1111111111111111111111111111111111111111", "info_json":{"factorio_version":"2.0", "dependencies":["base"]}}]
})).unwrap();
let requirements = fmm_core::version::parse_dependencies(&["a >= 3.0".into()]);
let plan = install::plan_dependencies(&requirements, &snapshot, &|_| Ok(full.clone()), "2.0");
assert!(
skip_dialog(&plan),
"normal M2 single-update shortcut applies"
);
tx.send(Message::Planned {
plan: Box::new(plan),
full: Default::default(),
roots: vec!["a".into()],
remove: false,
review_dependencies: true,
})
.unwrap();
runtime.drain(app);
assert!(app.get_operation_dialog());
assert!(app.get_operation_confirmable());
assert!(
runtime.pending.is_some(),
"no execution before confirmation"
);
app.set_operation_dialog(false);
runtime.idle(app);
manage.borrow_mut().toggle("a");
manage.borrow_mut().toggle("z");
let unrelated = manage
.borrow()
.pending
.iter()
.find(|(n, _)| n == "z")
.cloned()
.unwrap();
assert!(
runtime.begin_request(app, &["a".into()]),
"unsaved edits also allow removal"
);
let mut after = manage.borrow().snapshot.clone();
after.mods.retain(|m| m.name != "a");
tx.send(Message::Finished(
Report {
mods: vec![install::Outcome {
name: "a".into(),
ok: true,
message: format!("Moved to the {TRASH_NAME}"),
}],
},
Box::new(Ok(after)),
vec![],
))
.unwrap();
runtime.drain(app);
assert_eq!(manage.borrow().pending, [unrelated]);
assert!(!app.get_rows().iter().any(|m| m.name == "a"));
}
#[cfg(test)]
pub fn check_external_rescan(app: &ModsWindow, snapshot: Snapshot, cache: Cache) {
let mods_dir = snapshot.paths.mods_dir.clone();
let manage = Rc::new(RefCell::new(Controller::new(snapshot.clone())));
manage.borrow_mut().toggle("a");
manage.borrow_mut().select("z");
let (tx, rx) = mpsc::channel();
let mut runtime = Runtime {
manage: manage.clone(),
catalogue: Rc::new(RefCell::new(CatalogueController::new(&snapshot))),
cache,
tx: tx.clone(),
rx,
pending: None,
queue: Default::default(),
busy: true,
cleaned: true,
dirty: false,
rescanning: false,
watcher: None,
};
let installed =
|m: &Rc<RefCell<Controller>>| m.borrow().snapshot.mods.iter().any(|l| l.name == "outside");
std::fs::create_dir_all(mods_dir.join("outside")).unwrap();
std::fs::write(
mods_dir.join("outside/info.json"),
r#"{"name":"outside","title":"Outside","author":"A","version":"1.0.0","factorio_version":"2.0"}"#,
)
.unwrap();
// An operation in flight defers the outside change until idle.
tx.send(Message::Changed).unwrap();
runtime.drain(app);
assert!(runtime.dirty && !runtime.rescanning);
runtime.idle(app);
assert!(!runtime.dirty && runtime.rescanning);
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
while runtime.rescanning && std::time::Instant::now() < deadline {
std::thread::sleep(std::time::Duration::from_millis(20));
runtime.drain(app);
}
assert!(!runtime.rescanning, "worker rescan finished");
assert!(installed(&manage));
{
let c = manage.borrow();
assert_eq!(c.selection.as_deref(), Some("z"), "selection survives");
assert!(
c.pending.iter().any(|(name, _)| name == "a"),
"pending toggle survives"
);
}
use slint::Model;
assert!(app.get_rows().iter().any(|r| r.name == "outside"));
// A result that lands after an operation started is dropped and retried once idle.
std::fs::remove_dir_all(mods_dir.join("outside")).unwrap();
let stale = rescan(manage.borrow().snapshot.clone(), &runtime.cache).unwrap();
runtime.busy = true;
runtime.rescanning = true;
tx.send(Message::Rescanned(Box::new(Ok(stale)))).unwrap();
runtime.drain(app);
assert!(runtime.dirty && !runtime.rescanning);
assert!(installed(&manage), "busy runtime keeps its snapshot");
}