use crate::{commands::EntryPoint, config::ZerostashConfig, Stash};
use abscissa_core::{
application::{self, AppCell},
config::{self, CfgCell},
status_err, trace, Application, FrameworkError, StandardPaths,
};
use abscissa_tokio::TokioComponent;
use anyhow::Result;
use std::process;
pub static APP: AppCell<ZerostashApp> = AppCell::new();
#[derive(Debug)]
pub struct ZerostashApp {
config: CfgCell<ZerostashConfig>,
state: application::State<Self>,
}
impl Default for ZerostashApp {
fn default() -> Self {
Self {
config: CfgCell::default(),
state: application::State::default(),
}
}
}
impl Application for ZerostashApp {
type Cmd = EntryPoint;
type Cfg = ZerostashConfig;
type Paths = StandardPaths;
fn config(&self) -> config::Reader<ZerostashConfig> {
self.config.read()
}
fn state(&self) -> &application::State<Self> {
&self.state
}
fn register_components(&mut self, command: &Self::Cmd) -> Result<(), FrameworkError> {
let mut framework_components = self.framework_components(command)?;
framework_components.push(Box::new(TokioComponent::new()?));
let mut app_components = self.state.components_mut();
app_components.register(framework_components)
}
fn after_config(&mut self, config: Self::Cfg) -> Result<(), FrameworkError> {
let mut components = self.state.components_mut();
components.after_config(&config)?;
self.config.set_once(config);
Ok(())
}
fn tracing_config(&self, command: &EntryPoint) -> trace::Config {
if command.verbose {
trace::Config::verbose()
} else {
trace::Config::default()
}
}
}
impl ZerostashApp {
#[allow(clippy::redundant_closure)]
pub(crate) fn open_stash(&self, pathy: impl AsRef<str>) -> Stash {
let stash = self.config().open(pathy);
stash.unwrap_or_else(|e| fatal_error(e))
}
pub(crate) fn get_worker_threads(&self) -> usize {
use std::cmp;
cmp::min(num_cpus::get() + 1, 5)
}
}
pub fn fatal_error(err: impl Into<Box<dyn std::error::Error>>) -> ! {
status_err!("{} fatal error: {}", APP.name(), err.into());
process::exit(1)
}