//! The engine ended: say so, then reopen (ยง6.3). use std::{path::PathBuf, sync::Arc}; use ely_gpui_component::{feedback::Banner, primitives::Severity}; use gpui::{AppContext as _, Context}; use crate::{Closing as _, Dialog, Engine, Host, Opening as _, Recovering as _, Tabs as _, recover::clock, text}; /// Why the engine ended, and whether it is coming back. pub struct Stopped { why: String, restarting: bool, } pub trait Stopping: Host { /// After an engine error: asks if it ended. fn check_engine(&mut self, cx: &mut Context) { if self.core().stopped.is_some() { return; } let worker = Arc::clone(&self.core().worker); cx.spawn(async move |this, cx| { let ended = cx .background_spawn(async move { Self::Engine::ended(&mut worker.lock().expect("the worker lock")) }) .await; let Some(why) = ended else { return }; let noted = this.update(cx, |host, cx| { if host.core().stopped.is_none() { log::error!("{}: the engine ended ({why})", Self::KIND.app.slug()); host.core_mut().stopped = Some(Stopped { why, restarting: false }); cx.notify(); } }); if noted.is_err() { log::info!("office: the engine ended after its window"); } }) .detach(); } /// What ended, the last point, and the way back. fn stopped_banner(&self, cx: &mut Context) -> Option { let stopped = self.core().stopped.as_ref()?; let at = match self.core().keeping.as_ref().and_then(|keeping| keeping.last) { Some(at) => clock(at), None => text(cx, "office.stopped.never", &[]).to_string(), }; let said = text(cx, "office.stopped", &[("why", &stopped.why), ("at", &at)]); let banner = Banner::new("office-stopped", Severity::Danger, said); if stopped.restarting { return Some(banner); } let this = cx.entity(); Some(banner.action(text(cx, "office.stopped.reopen", &[]), move |_, cx| { this.update(cx, |host, cx| host.restart_engine(cx)) })) } /// A new worker, then each tab from point or file. fn restart_engine(&mut self, cx: &mut Context) { let Some(stopped) = self.core_mut().stopped.as_mut() else { return }; stopped.restarting = true; cx.notify(); let worker = Arc::clone(&self.core().worker); cx.spawn(async move |this, cx| { let restarted = cx .background_spawn(async move { Self::Engine::restart(Self::KIND.app, &mut worker.lock().expect("the worker lock")) }) .await; let reopened = this.update(cx, |host, cx| match restarted { Ok(()) => host.reopen_all(cx), Err(error) => { log::error!("{}: the engine does not restart: {error}", Self::KIND.app.slug()); host.core_mut().stopped = Some(Stopped { why: error.to_string(), restarting: false }); cx.notify(); } }); if reopened.is_err() { log::info!("office: the engine restarted after its window"); } }) .detach(); } /// Unsaved tabs from their newest point, clean ones from file. fn reopen_all(&mut self, cx: &mut Context) { self.core_mut().stopped = None; let tabs: Vec<(u64, String, Option, bool)> = self .core() .tabs .iter() .map(|tab| (tab.id, tab.name.to_string(), tab.session.path().map(PathBuf::from), tab.dirty(cx))) .collect(); let mut lost = Vec::new(); for (id, name, path, dirty) in tabs { if !dirty { self.release_tab(id, cx); if let Some(path) = path { self.open_file(path, cx); } continue; } match self.reopen_point(id, cx) { Ok(true) => {} Ok(false) => lost.push(name), Err(error) => { log::error!("office: tab {id} point does not open ({:?})", error.kind()); lost.push(format!("{name} ({error})")); } } self.release_tab(id, cx); } // Questions about the released tabs have no answer now. if matches!(self.core().dialog, Some(Dialog::Unsaved { .. } | Dialog::Conflict { .. })) { self.core_mut().dialog = None; } log::info!("{}: the engine is back, {} tab(s) lost", Self::KIND.app.slug(), lost.len()); if !lost.is_empty() { let shown = text(cx, "office.stopped.lost", &[("names", &lost.join(", "))]); self.toast_unlogged(shown, Severity::Danger, cx); } } } impl Stopping for H {}