You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
204 lines
6.2 KiB
204 lines
6.2 KiB
use super::runnable::Runnable;
|
|
use super::setup::Setup;
|
|
use super::util::{AddableResource, InternalAddResult};
|
|
use super::SymbolRunner;
|
|
use crate::async_utils::join;
|
|
use crate::loggers::{Logger, StoringLogger};
|
|
use crate::resources::{FromArtifact, FromResource};
|
|
use crate::symbols::Symbol;
|
|
use crate::to_artifact::ToArtifact;
|
|
use crate::{ImplementationBuilder, ResourceLocator};
|
|
use async_trait::async_trait;
|
|
use std::error::Error;
|
|
use std::fmt::Debug;
|
|
use std::hash::Hash;
|
|
use std::marker::PhantomData;
|
|
|
|
#[async_trait(?Send)]
|
|
pub trait AddGeneric<X: ToArtifact> {
|
|
async fn add_generic(&self, x: X) -> InternalAddResult<X>;
|
|
}
|
|
|
|
macro_rules! add_generic {
|
|
( $($name:ident)* ) => (
|
|
#[async_trait(?Send)]
|
|
#[allow(non_snake_case)]
|
|
impl<SR: 'static, _L: 'static, _B: 'static, Rs: 'static + Hash + Eq, As: 'static + Clone, $($name: AddableResource,)*>
|
|
AddGeneric<($($name,)*)> for Setup<SR, _L, _B, Rs, As>
|
|
where
|
|
$(
|
|
RegularSetupCore<SR, _L, _B>: SetupCore<$name, Self>,
|
|
As: FromArtifact<$name>,
|
|
Rs: FromResource<$name>,
|
|
$name::Artifact: Clone
|
|
),*
|
|
{
|
|
#[allow(unused, clippy::shadow_unrelated)]
|
|
async fn add_generic(&self, ($($name,)*): ($($name,)*)) -> Result<(StoringLogger, ($($name::Artifact,)*), bool), (StoringLogger, Box<dyn Error>)>
|
|
{
|
|
let ($($name,)*) = join!($(self.add($name, false),)*);
|
|
let logger = StoringLogger::default();
|
|
let mut did_run_any = false;
|
|
$(
|
|
let (log, artifact, did_run) = $name?;
|
|
logger.put(log.release());
|
|
did_run_any = did_run_any || did_run;
|
|
let $name = artifact;
|
|
)*
|
|
Ok((logger, ($($name,)*), did_run_any))
|
|
}
|
|
}
|
|
);
|
|
}
|
|
|
|
for_each_tuple!(add_generic);
|
|
|
|
// This is for self-referential T
|
|
// FIXME: Wait for specialization
|
|
#[async_trait(?Send)]
|
|
impl<
|
|
SR: 'static + SymbolRunner,
|
|
T: AddableResource,
|
|
Rs: 'static + Hash + Eq + FromResource<T>,
|
|
As: 'static + FromArtifact<T> + Clone,
|
|
L: 'static + ResourceLocator<T, Prerequisites = Option<T>>,
|
|
B: 'static + ImplementationBuilder<T>,
|
|
> AddGeneric<Option<T>> for Setup<SR, L, B, Rs, As>
|
|
where
|
|
<B as ImplementationBuilder<T>>::Implementation: Runnable + Debug,
|
|
Self: AddGeneric<B::Prerequisites>,
|
|
T::Artifact: Clone,
|
|
{
|
|
async fn add_generic(&self, r: Option<T>) -> InternalAddResult<Option<T>> {
|
|
Ok(match r {
|
|
Some(r) => {
|
|
let (logger, result, did_run) = self.add(r, false).await?;
|
|
(logger, Some(result), did_run)
|
|
}
|
|
None => (StoringLogger::default(), None, false),
|
|
})
|
|
}
|
|
}
|
|
|
|
#[async_trait(?Send)]
|
|
impl<
|
|
T: AddableResource,
|
|
Rs: 'static + Hash + Eq + FromResource<T>,
|
|
As: 'static + FromArtifact<T> + Clone,
|
|
SR: 'static,
|
|
L: 'static,
|
|
B: 'static,
|
|
> AddGeneric<T> for Setup<SR, L, B, Rs, As>
|
|
where
|
|
T::Artifact: Clone,
|
|
RegularSetupCore<SR, L, B>: 'static + SetupCore<T, Self>,
|
|
{
|
|
async fn add_generic(&self, r: T) -> InternalAddResult<T> {
|
|
self.add(r, false).await
|
|
}
|
|
}
|
|
|
|
#[async_trait(?Send)]
|
|
pub trait SetupCore<R: AddableResource, S> {
|
|
async fn add<RR: AsRef<R>>(
|
|
&self,
|
|
setup: &S,
|
|
resource: RR,
|
|
force_run: bool,
|
|
) -> InternalAddResult<R>;
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct RegularSetupCore<SR, L, B> {
|
|
symbol_runner: SR,
|
|
phantom: PhantomData<(L, B)>,
|
|
}
|
|
|
|
impl<SR, L, B> RegularSetupCore<SR, L, B> {
|
|
pub fn new(symbol_runner: SR) -> Self {
|
|
Self {
|
|
symbol_runner,
|
|
phantom: PhantomData::default(),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[async_trait(?Send)]
|
|
impl<SR: SymbolRunner, L, B, R: AddableResource, S> SetupCore<R, S> for RegularSetupCore<SR, L, B>
|
|
where
|
|
B: ImplementationBuilder<R>,
|
|
<B as ImplementationBuilder<R>>::Implementation: Runnable + Debug,
|
|
L: ResourceLocator<R>,
|
|
S: AddGeneric<B::Prerequisites> + AddGeneric<<L as ResourceLocator<R>>::Prerequisites>,
|
|
{
|
|
async fn add<RR: AsRef<R>>(
|
|
&self,
|
|
setup: &S,
|
|
resource: RR,
|
|
force_run: bool,
|
|
) -> InternalAddResult<R> {
|
|
let resource = resource.as_ref();
|
|
let logger = StoringLogger::new();
|
|
logger.write(4, format!("Adding {:?} ... ", resource));
|
|
logger.write(4, format!("(force_run is {})", force_run));
|
|
let (location, location_prereqs) = L::locate(resource);
|
|
logger.trace(format!("Adding location prereqs for {:?}", resource));
|
|
let result = setup.add_generic(location_prereqs).await;
|
|
if let Err((log, e)) = result {
|
|
logger.put(log.release());
|
|
return Err((logger, e));
|
|
}
|
|
let (location_prereq_logger, _, location_prereqs_did_run) = result.unwrap();
|
|
logger.put(location_prereq_logger.release());
|
|
logger.trace(format!(
|
|
"Location prereqs for {:?} did_run: {}",
|
|
resource, location_prereqs_did_run
|
|
));
|
|
logger.trace(format!("Adding implementation prereqs for {:?}", resource));
|
|
let result = setup.add_generic(B::prerequisites(resource)).await;
|
|
if let Err((log, e)) = result {
|
|
logger.put(log.release());
|
|
return Err((logger, e));
|
|
}
|
|
let (impl_prereq_logger, prereqs, prereqs_did_run) = result.unwrap();
|
|
logger.put(impl_prereq_logger.release());
|
|
logger.trace(format!(
|
|
"Implementation prereqs for {:?} did_run: {}",
|
|
resource, prereqs_did_run
|
|
));
|
|
logger.trace(format!("Running implementation for {:?}", resource));
|
|
let implementation = B::create(resource, &location, prereqs);
|
|
let did_run_result = implementation
|
|
.run(
|
|
&self.symbol_runner,
|
|
&logger,
|
|
force_run || location_prereqs_did_run || prereqs_did_run,
|
|
)
|
|
.await;
|
|
match did_run_result {
|
|
Ok(did_run) => {
|
|
logger.write(4, "done.");
|
|
Ok((logger, location, did_run))
|
|
}
|
|
Err(e) => Err((logger, e)),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[async_trait(?Send)]
|
|
impl<SR: SymbolRunner, L, B> SymbolRunner for RegularSetupCore<SR, L, B> {
|
|
async fn run_symbol<S: Symbol + Debug, LOG: Logger>(
|
|
&self,
|
|
symbol: &S,
|
|
parent_logger: &LOG,
|
|
force: bool,
|
|
) -> Result<bool, Box<dyn Error>> {
|
|
let logger = StoringLogger::new();
|
|
logger.write(4, format!("Directly running {:?} ...", symbol));
|
|
let result = self.symbol_runner.run_symbol(symbol, &logger, force).await;
|
|
logger.write(4, "done.");
|
|
let max_level = if result.is_err() { 5 } else { 3 };
|
|
parent_logger.put(logger.release().into_iter().filter(|e| e.0 <= max_level));
|
|
result
|
|
}
|
|
}
|