44 changed files with 2081 additions and 1242 deletions
-
5Cargo.toml
-
87src/async_utils.rs
-
200src/builder.rs
-
124src/command_runner.rs
-
19src/lib.rs
-
2src/locator.rs
-
125src/loggers.rs
-
43src/resources/mod.rs
-
274src/schema.rs
-
396src/setup.rs
-
191src/setup/core.rs
-
10src/setup/mod.rs
-
193src/setup/runnable.rs
-
300src/setup/setup.rs
-
318src/setup/symbol_runner.rs
-
9src/setup/util.rs
-
23src/symbols/acme/cert.rs
-
6src/symbols/concat.rs
-
21src/symbols/cron.rs
-
6src/symbols/dir.rs
-
6src/symbols/file.rs
-
102src/symbols/git/checkout.rs
-
2src/symbols/git/mod.rs
-
43src/symbols/git/submodules.rs
-
23src/symbols/mariadb/database.rs
-
23src/symbols/mariadb/dump.rs
-
20src/symbols/mariadb/user.rs
-
6src/symbols/mod.rs
-
23src/symbols/npm.rs
-
12src/symbols/owner.rs
-
38src/symbols/postgresql/database.rs
-
37src/symbols/saved_directory.rs
-
12src/symbols/systemd/reload.rs
-
47src/symbols/systemd/user_service.rs
-
7src/symbols/systemd/user_session.rs
-
21src/symbols/tls/csr.rs
-
18src/symbols/tls/key.rs
-
22src/symbols/user.rs
-
29src/symbols/wordpress/plugin.rs
-
16src/symbols/wordpress/translation.rs
-
1src/templates/nginx/server.rs
-
2src/to_artifact.rs
-
53tests/file.rs
-
30tests/setup.rs
@ -0,0 +1,87 @@ |
|||||
|
use std::{
|
||||
|
future::Future,
|
||||
|
pin::Pin,
|
||||
|
sync::{Arc, Mutex},
|
||||
|
task::{Context, Poll, Waker},
|
||||
|
thread,
|
||||
|
time::Duration,
|
||||
|
};
|
||||
|
|
||||
|
pub use async_trait::async_trait;
|
||||
|
|
||||
|
pub fn run<F: Future>(future: F) -> F::Output {
|
||||
|
tokio::runtime::Runtime::new().unwrap().block_on(future)
|
||||
|
}
|
||||
|
pub use tokio::try_join;
|
||||
|
|
||||
|
#[derive(Debug)]
|
||||
|
pub struct TimerFuture {
|
||||
|
state: Arc<Mutex<State>>,
|
||||
|
}
|
||||
|
|
||||
|
#[derive(Debug)]
|
||||
|
enum State {
|
||||
|
NotStarted(Duration),
|
||||
|
Running(Waker),
|
||||
|
Completed,
|
||||
|
}
|
||||
|
|
||||
|
impl Future for TimerFuture {
|
||||
|
type Output = ();
|
||||
|
fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
|
||||
|
let mut state = self.state.lock().unwrap();
|
||||
|
if let State::Completed = *state {
|
||||
|
return Poll::Ready(());
|
||||
|
}
|
||||
|
|
||||
|
if let State::NotStarted(duration) = *state {
|
||||
|
let thread_state = self.state.clone();
|
||||
|
thread::spawn(move || {
|
||||
|
thread::sleep(duration);
|
||||
|
let mut state = thread_state.lock().unwrap();
|
||||
|
let waker = if let State::Running(waker) = &*state {
|
||||
|
Some(waker.clone())
|
||||
|
} else {
|
||||
|
None
|
||||
|
};
|
||||
|
*state = State::Completed;
|
||||
|
if let Some(w) = waker {
|
||||
|
w.wake()
|
||||
|
}
|
||||
|
});
|
||||
|
}
|
||||
|
|
||||
|
*state = State::Running(cx.waker().clone());
|
||||
|
Poll::Pending
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
pub fn sleep(duration: Duration) -> impl Future<Output = ()> {
|
||||
|
TimerFuture {
|
||||
|
state: Arc::new(Mutex::new(State::NotStarted(duration))),
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
#[cfg(test)]
|
||||
|
mod test {
|
||||
|
use crate::async_utils::{run, sleep};
|
||||
|
use futures::future::FutureExt;
|
||||
|
use std::time::{Duration, Instant};
|
||||
|
|
||||
|
#[test]
|
||||
|
fn test_sleep() {
|
||||
|
run(async {
|
||||
|
let start = Instant::now();
|
||||
|
let sleep = sleep(Duration::from_millis(100)).fuse();
|
||||
|
let ok = async {}.fuse();
|
||||
|
futures::pin_mut!(sleep, ok);
|
||||
|
loop {
|
||||
|
futures::select! {
|
||||
|
_ = sleep => {},
|
||||
|
_ = ok => assert!((Instant::now() - start).as_millis() < 100),
|
||||
|
complete => break,
|
||||
|
}
|
||||
|
}
|
||||
|
})
|
||||
|
}
|
||||
|
}
|
||||
@ -1,274 +0,0 @@ |
|||||
use crate::loggers::Logger;
|
|
||||
use crate::symbols::Symbol;
|
|
||||
use std::cell::RefCell;
|
|
||||
use std::error::Error;
|
|
||||
use std::fmt;
|
|
||||
use std::fmt::Debug;
|
|
||||
|
|
||||
pub trait SymbolRunner {
|
|
||||
fn run_symbol<S: Symbol + Debug>(&self, symbol: &S, force: bool) -> Result<bool, Box<dyn Error>>;
|
|
||||
}
|
|
||||
|
|
||||
impl<R: SymbolRunner + ?Sized> SymbolRunner for Box<R> {
|
|
||||
fn run_symbol<S: Symbol + Debug>(&self, symbol: &S, force: bool) -> Result<bool, Box<dyn Error>> {
|
|
||||
(**self).run_symbol(symbol, force)
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
#[derive(Debug)]
|
|
||||
pub enum SymbolRunError {
|
|
||||
Symbol(Box<dyn Error>),
|
|
||||
ExecuteDidNotReach(()),
|
|
||||
}
|
|
||||
|
|
||||
impl Error for SymbolRunError {
|
|
||||
fn cause(&self) -> Option<&dyn Error> {
|
|
||||
match self {
|
|
||||
Self::Symbol(ref e) => Some(&**e),
|
|
||||
Self::ExecuteDidNotReach(_) => None,
|
|
||||
}
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
impl fmt::Display for SymbolRunError {
|
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
||||
match self {
|
|
||||
Self::Symbol(ref e) => write!(f, "{}", e),
|
|
||||
Self::ExecuteDidNotReach(_) => write!(f, "Target not reached after executing symbol"),
|
|
||||
}
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
pub struct InitializingSymbolRunner<L: Logger> {
|
|
||||
logger: RefCell<L>,
|
|
||||
}
|
|
||||
|
|
||||
impl<L: Logger> InitializingSymbolRunner<L> {
|
|
||||
pub fn new(logger: L) -> Self {
|
|
||||
Self {
|
|
||||
logger: RefCell::new(logger),
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
fn exec_symbol<S: Symbol + Debug>(&self, symbol: &S) -> Result<(), Box<dyn Error>> {
|
|
||||
let mut logger = self.logger.borrow_mut();
|
|
||||
logger.write(format!("Executing {:?}", symbol).as_str());
|
|
||||
symbol.execute()?;
|
|
||||
let target_reached = symbol.target_reached()?;
|
|
||||
logger.debug(
|
|
||||
format!(
|
|
||||
"Symbol reports target_reached: {:?} (should be true)",
|
|
||||
target_reached
|
|
||||
)
|
|
||||
.as_str(),
|
|
||||
);
|
|
||||
if target_reached {
|
|
||||
Ok(())
|
|
||||
} else {
|
|
||||
Err(Box::new(SymbolRunError::ExecuteDidNotReach(())))
|
|
||||
}
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
impl<L: Logger> SymbolRunner for InitializingSymbolRunner<L> {
|
|
||||
fn run_symbol<S: Symbol + Debug>(&self, symbol: &S, force: bool) -> Result<bool, Box<dyn Error>> {
|
|
||||
let mut logger = self.logger.borrow_mut();
|
|
||||
let executed = if force {
|
|
||||
logger.debug("Forcing symbol execution");
|
|
||||
drop(logger);
|
|
||||
self.exec_symbol(symbol)?;
|
|
||||
true
|
|
||||
} else {
|
|
||||
let target_reached = symbol.target_reached()?;
|
|
||||
if target_reached {
|
|
||||
logger.write(format!("{:?} already reached", symbol).as_str());
|
|
||||
} else {
|
|
||||
logger.debug(format!("Symbol reports target_reached: {:?}", target_reached).as_str());
|
|
||||
drop(logger);
|
|
||||
self.exec_symbol(symbol)?;
|
|
||||
}
|
|
||||
!target_reached
|
|
||||
};
|
|
||||
Ok(executed)
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
pub struct DrySymbolRunner<L: Logger> {
|
|
||||
logger: RefCell<L>,
|
|
||||
}
|
|
||||
|
|
||||
impl<L: Logger> DrySymbolRunner<L> {
|
|
||||
pub fn new(logger: L) -> Self {
|
|
||||
Self {
|
|
||||
logger: RefCell::new(logger),
|
|
||||
}
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
impl<L: Logger> SymbolRunner for DrySymbolRunner<L> {
|
|
||||
fn run_symbol<S: Symbol + Debug>(&self, symbol: &S, force: bool) -> Result<bool, Box<dyn Error>> {
|
|
||||
let mut logger = self.logger.borrow_mut();
|
|
||||
let would_execute = if force {
|
|
||||
logger.write(format!("Would force-execute {:?}", symbol).as_str());
|
|
||||
true
|
|
||||
} else {
|
|
||||
let target_reached = symbol.target_reached()?;
|
|
||||
logger.debug(format!("Symbol reports target_reached: {:?}", target_reached).as_str());
|
|
||||
if !target_reached {
|
|
||||
logger.write(format!("Would execute {:?}", symbol).as_str());
|
|
||||
}
|
|
||||
!target_reached
|
|
||||
};
|
|
||||
Ok(would_execute)
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
pub struct ReportingSymbolRunner<'a, R, L>(&'a R, RefCell<L>);
|
|
||||
|
|
||||
impl<'a, R, L> ReportingSymbolRunner<'a, R, L> {
|
|
||||
pub fn new(symbol_runner: &'a R, logger: L) -> Self {
|
|
||||
ReportingSymbolRunner(symbol_runner, RefCell::new(logger))
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
impl<'a, R, L> SymbolRunner for ReportingSymbolRunner<'a, R, L>
|
|
||||
where
|
|
||||
R: SymbolRunner,
|
|
||||
L: Logger,
|
|
||||
{
|
|
||||
fn run_symbol<S: Symbol + Debug>(&self, symbol: &S, force: bool) -> Result<bool, Box<dyn Error>> {
|
|
||||
let mut logger = self.1.borrow_mut();
|
|
||||
logger.debug(format!("Running symbol {:?}", symbol).as_str());
|
|
||||
let res = self.0.run_symbol(symbol, force);
|
|
||||
if let Err(ref e) = res {
|
|
||||
logger.write(format!("Failed on {:?} with {}, aborting.", symbol, e).as_str())
|
|
||||
} else {
|
|
||||
logger.debug(format!("Successfully finished {:?}", symbol).as_str())
|
|
||||
}
|
|
||||
res
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
#[cfg(test)]
|
|
||||
mod test {
|
|
||||
use std::cell::RefCell;
|
|
||||
use std::error::Error;
|
|
||||
use std::fmt;
|
|
||||
|
|
||||
use crate::loggers::Logger;
|
|
||||
use crate::schema::InitializingSymbolRunner;
|
|
||||
use crate::schema::SymbolRunner;
|
|
||||
use crate::symbols::Symbol;
|
|
||||
|
|
||||
#[derive(Debug, PartialEq, Clone)]
|
|
||||
enum DummySymbolError {
|
|
||||
Error(()),
|
|
||||
}
|
|
||||
|
|
||||
impl Error for DummySymbolError {}
|
|
||||
|
|
||||
impl fmt::Display for DummySymbolError {
|
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
||||
write!(f, "Dummy symbol error")
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
#[derive(Debug)]
|
|
||||
struct DummySymbol<T, E> {
|
|
||||
_target_reached: RefCell<T>,
|
|
||||
_execute: RefCell<E>,
|
|
||||
}
|
|
||||
|
|
||||
impl<
|
|
||||
E: Iterator<Item = Result<(), Box<dyn Error>>>,
|
|
||||
T: Iterator<Item = Result<bool, Box<dyn Error>>>,
|
|
||||
> Symbol for DummySymbol<T, E>
|
|
||||
{
|
|
||||
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
|
|
||||
self._target_reached.borrow_mut().next().unwrap()
|
|
||||
}
|
|
||||
fn execute(&self) -> Result<(), Box<dyn Error>> {
|
|
||||
self._execute.borrow_mut().next().unwrap()
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
impl<
|
|
||||
E: Iterator<Item = Result<(), Box<dyn Error>>>,
|
|
||||
T: Iterator<Item = Result<bool, Box<dyn Error>>>,
|
|
||||
> DummySymbol<T, E>
|
|
||||
{
|
|
||||
fn new<
|
|
||||
IE: IntoIterator<IntoIter = E, Item = Result<(), Box<dyn Error>>>,
|
|
||||
IT: IntoIterator<IntoIter = T, Item = Result<bool, Box<dyn Error>>>,
|
|
||||
>(
|
|
||||
target_reached: IT,
|
|
||||
execute: IE,
|
|
||||
) -> Self {
|
|
||||
Self {
|
|
||||
_target_reached: RefCell::new(target_reached.into_iter()),
|
|
||||
_execute: RefCell::new(execute.into_iter()),
|
|
||||
}
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
struct DummyLogger {
|
|
||||
log: Vec<String>,
|
|
||||
}
|
|
||||
|
|
||||
impl DummyLogger {
|
|
||||
fn new() -> DummyLogger {
|
|
||||
DummyLogger { log: Vec::new() }
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
impl Logger for DummyLogger {
|
|
||||
fn write(&mut self, line: &str) {
|
|
||||
self.log.push(line.into());
|
|
||||
}
|
|
||||
fn debug(&mut self, line: &str) {
|
|
||||
self.log.push(line.into());
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
#[test]
|
|
||||
fn nothing_needed_to_be_done() {
|
|
||||
let result = InitializingSymbolRunner::new(DummyLogger::new())
|
|
||||
.run_symbol(&DummySymbol::new(vec![Ok(true)], vec![Ok(())]), false);
|
|
||||
assert!(result.is_ok());
|
|
||||
}
|
|
||||
|
|
||||
#[test]
|
|
||||
fn everything_is_ok() {
|
|
||||
let result = InitializingSymbolRunner::new(DummyLogger::new()).run_symbol(
|
|
||||
&DummySymbol::new(vec![Ok(true), Ok(false)], vec![Ok(())]),
|
|
||||
false,
|
|
||||
);
|
|
||||
assert!(result.is_ok());
|
|
||||
}
|
|
||||
|
|
||||
#[test]
|
|
||||
fn executing_did_not_change_state() {
|
|
||||
let result = InitializingSymbolRunner::new(DummyLogger::new()).run_symbol(
|
|
||||
&DummySymbol::new(vec![Ok(false), Ok(false)], vec![Ok(())]),
|
|
||||
false,
|
|
||||
);
|
|
||||
assert_eq!(
|
|
||||
result.unwrap_err().to_string(),
|
|
||||
"Target not reached after executing symbol"
|
|
||||
);
|
|
||||
}
|
|
||||
|
|
||||
#[test]
|
|
||||
fn executing_did_not_work() {
|
|
||||
let err = InitializingSymbolRunner::new(DummyLogger::new())
|
|
||||
.run_symbol(
|
|
||||
&DummySymbol::new(
|
|
||||
vec![Ok(false)],
|
|
||||
vec![Err(Box::new(DummySymbolError::Error(())) as Box<dyn Error>)],
|
|
||||
),
|
|
||||
false,
|
|
||||
)
|
|
||||
.unwrap_err();
|
|
||||
assert_eq!(err.to_string(), "Dummy symbol error");
|
|
||||
}
|
|
||||
}
|
|
||||
@ -1,396 +0,0 @@ |
|||||
use crate::resources::{BorrowResource, DefaultResources, Resource};
|
|
||||
use crate::schema::SymbolRunner;
|
|
||||
use crate::symbols::Symbol;
|
|
||||
use crate::to_artifact::ToArtifact;
|
|
||||
use crate::{DefaultBuilder, DefaultLocator, ResourceLocator, SymbolBuilder};
|
|
||||
use std::collections::HashSet;
|
|
||||
use std::error::Error;
|
|
||||
use std::fmt::Debug;
|
|
||||
use std::hash::Hash;
|
|
||||
use std::marker::PhantomData;
|
|
||||
|
|
||||
pub trait CanHandle<X: ToArtifact> {
|
|
||||
fn handle(&mut self, x: X) -> Result<(X::Artifact, bool), Box<dyn Error>>;
|
|
||||
}
|
|
||||
|
|
||||
macro_rules! can_handle {
|
|
||||
( $($name:ident)* ) => (
|
|
||||
#[allow(non_snake_case)]
|
|
||||
impl<_SR: SymbolRunner, _L, _R: Hash + Eq, _B, $($name: Resource,)*>
|
|
||||
CanHandle<($($name,)*)>
|
|
||||
for Setup<_SR, _L, _R, _B>
|
|
||||
where
|
|
||||
$(
|
|
||||
_B: SymbolBuilder<$name>,
|
|
||||
<_B as SymbolBuilder<$name>>::Symbol: Runnable + Debug,
|
|
||||
_L: ResourceLocator<$name>,
|
|
||||
_R: From<$name> + BorrowResource<$name>,
|
|
||||
Self: CanHandle<<_B as SymbolBuilder<$name>>::Prerequisites> +
|
|
||||
CanHandle<<_L as ResourceLocator<$name>>::Prerequisites>
|
|
||||
),*
|
|
||||
{
|
|
||||
fn handle(&mut self, ($($name,)*): ($($name,)*)) -> Result<(($($name::Artifact,)*), bool), Box<dyn Error>>
|
|
||||
{
|
|
||||
$(let $name = self.add($name)?;)*
|
|
||||
Ok((($($name.0,)*), false $(|| $name.1)*))
|
|
||||
}
|
|
||||
}
|
|
||||
);
|
|
||||
}
|
|
||||
|
|
||||
for_each_tuple!(can_handle);
|
|
||||
|
|
||||
// This is for self-referential T
|
|
||||
// FIXME: Wait for specialization
|
|
||||
impl<_SR: SymbolRunner, _L, _R: Hash + Eq, _B, T: Resource> CanHandle<Option<T>>
|
|
||||
for Setup<_SR, _L, _R, _B>
|
|
||||
where
|
|
||||
_B: SymbolBuilder<T>,
|
|
||||
<_B as SymbolBuilder<T>>::Symbol: Runnable + Debug,
|
|
||||
_L: ResourceLocator<T, Prerequisites = Option<T>>,
|
|
||||
_R: From<T> + BorrowResource<T>,
|
|
||||
Self: CanHandle<<_B as SymbolBuilder<T>>::Prerequisites>,
|
|
||||
{
|
|
||||
fn handle(
|
|
||||
&mut self,
|
|
||||
r: Option<T>,
|
|
||||
) -> Result<(<Option<T> as ToArtifact>::Artifact, bool), Box<dyn Error>> {
|
|
||||
Ok(match r {
|
|
||||
Some(r) => {
|
|
||||
let (result, did_run) = self.add(r)?;
|
|
||||
(Some(result), did_run)
|
|
||||
}
|
|
||||
None => (None, false),
|
|
||||
})
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
impl<_SR: SymbolRunner, _L, _R: Hash + Eq, _B, T: Resource> CanHandle<T> for Setup<_SR, _L, _R, _B>
|
|
||||
where
|
|
||||
_B: SymbolBuilder<T>,
|
|
||||
<_B as SymbolBuilder<T>>::Symbol: Runnable + Debug,
|
|
||||
_L: ResourceLocator<T>,
|
|
||||
_R: From<T> + Debug + BorrowResource<T>,
|
|
||||
Self: CanHandle<<_B as SymbolBuilder<T>>::Prerequisites>
|
|
||||
+ CanHandle<<_L as ResourceLocator<T>>::Prerequisites>,
|
|
||||
{
|
|
||||
fn handle(&mut self, r: T) -> Result<(<T as ToArtifact>::Artifact, bool), Box<dyn Error>> {
|
|
||||
self.add(r)
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
pub struct Setup<
|
|
||||
SR,
|
|
||||
L = DefaultLocator,
|
|
||||
R = DefaultResources<'static, &'static str>,
|
|
||||
B = DefaultBuilder,
|
|
||||
> {
|
|
||||
symbol_runner: SR,
|
|
||||
resources: HashSet<R>,
|
|
||||
phantom: PhantomData<(L, B)>,
|
|
||||
}
|
|
||||
|
|
||||
// https://github.com/rust-lang/rust/issues/27336
|
|
||||
impl<SR> Setup<SR> {
|
|
||||
pub fn new(symbol_runner: SR) -> Self {
|
|
||||
Self {
|
|
||||
symbol_runner,
|
|
||||
resources: Default::default(),
|
|
||||
phantom: Default::default(),
|
|
||||
}
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
impl<SR, L, R: Hash + Eq, B> Setup<SR, L, R, B> {
|
|
||||
pub fn new_with(symbol_runner: SR) -> Self {
|
|
||||
Self {
|
|
||||
symbol_runner,
|
|
||||
resources: Default::default(),
|
|
||||
phantom: Default::default(),
|
|
||||
}
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
pub trait Runnable {
|
|
||||
fn run<R: SymbolRunner>(&self, runner: &R, force: bool) -> Result<bool, Box<dyn Error>>;
|
|
||||
}
|
|
||||
|
|
||||
impl<S: Symbol + Debug> Runnable for S {
|
|
||||
fn run<R: SymbolRunner>(&self, runner: &R, force: bool) -> Result<bool, Box<dyn Error>> {
|
|
||||
runner.run_symbol(self, force)
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
macro_rules! runnable_for_tuple {
|
|
||||
( $($name:ident)* ) => (
|
|
||||
#[allow(non_snake_case)]
|
|
||||
impl<$($name: Symbol + Debug,)*> Runnable for ($($name,)*) {
|
|
||||
#[allow(unused)]
|
|
||||
fn run<_R: SymbolRunner>(&self, runner: &_R, force: bool) -> Result<bool, Box<dyn Error>> {
|
|
||||
let ($($name,)*) = self;
|
|
||||
let mut result = false;
|
|
||||
$(result = runner.run_symbol($name, force || result)? || result;)*
|
|
||||
Ok(result)
|
|
||||
}
|
|
||||
}
|
|
||||
);
|
|
||||
}
|
|
||||
|
|
||||
for_each_tuple!(runnable_for_tuple);
|
|
||||
|
|
||||
impl<SR: SymbolRunner, L, Rs: Hash + Eq, B> Setup<SR, L, Rs, B> {
|
|
||||
pub fn add<R: Resource>(&mut self, resource: R) -> Result<(R::Artifact, bool), Box<dyn Error>>
|
|
||||
where
|
|
||||
B: SymbolBuilder<R>,
|
|
||||
<B as SymbolBuilder<R>>::Symbol: Runnable + Debug,
|
|
||||
L: ResourceLocator<R>,
|
|
||||
Rs: From<R> + BorrowResource<R>,
|
|
||||
Self: CanHandle<B::Prerequisites> + CanHandle<<L as ResourceLocator<R>>::Prerequisites>,
|
|
||||
{
|
|
||||
self.add_force(resource, false)
|
|
||||
}
|
|
||||
|
|
||||
pub fn add_force<R: Resource>(
|
|
||||
&mut self,
|
|
||||
resource: R,
|
|
||||
force_run: bool,
|
|
||||
) -> Result<(R::Artifact, bool), Box<dyn Error>>
|
|
||||
where
|
|
||||
B: SymbolBuilder<R>,
|
|
||||
<B as SymbolBuilder<R>>::Symbol: Runnable + Debug,
|
|
||||
L: ResourceLocator<R>,
|
|
||||
Rs: From<R> + BorrowResource<R>,
|
|
||||
Self: CanHandle<B::Prerequisites> + CanHandle<<L as ResourceLocator<R>>::Prerequisites>,
|
|
||||
{
|
|
||||
let (target, target_prereqs) = L::locate(&resource);
|
|
||||
let storable_resource = Rs::from(resource);
|
|
||||
let did_run = if self.resources.get(&storable_resource).is_some() {
|
|
||||
assert!(
|
|
||||
!force_run,
|
|
||||
"Forcing to run an already-added resource is a logical error"
|
|
||||
);
|
|
||||
false
|
|
||||
} else {
|
|
||||
let (_, target_prereqs_did_run) = self.handle(target_prereqs)?;
|
|
||||
let (symbol, prereqs_did_run) =
|
|
||||
self.get_symbol(storable_resource.borrow_resource().unwrap(), &target)?;
|
|
||||
self.resources.insert(storable_resource);
|
|
||||
self.run_symbol(
|
|
||||
symbol,
|
|
||||
force_run || target_prereqs_did_run || prereqs_did_run,
|
|
||||
)?
|
|
||||
};
|
|
||||
Ok((target, did_run))
|
|
||||
}
|
|
||||
|
|
||||
fn get_symbol<R: Resource>(
|
|
||||
&mut self,
|
|
||||
resource: &R,
|
|
||||
target: &R::Artifact,
|
|
||||
) -> Result<(<B as SymbolBuilder<R>>::Symbol, bool), Box<dyn Error>>
|
|
||||
where
|
|
||||
B: SymbolBuilder<R>,
|
|
||||
Self: CanHandle<B::Prerequisites>,
|
|
||||
{
|
|
||||
let (prereqs, prereqs_did_run) = self.handle(B::prerequisites(resource))?;
|
|
||||
Ok((B::create(resource, target, prereqs), prereqs_did_run))
|
|
||||
}
|
|
||||
|
|
||||
pub fn run_symbol<S: Runnable>(&self, symbol: S, force: bool) -> Result<bool, Box<dyn Error>> {
|
|
||||
symbol.run(&self.symbol_runner, force)
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
#[cfg(test)]
|
|
||||
mod test {
|
|
||||
use crate::resources::{BorrowResource, Resource};
|
|
||||
use crate::schema::SymbolRunner;
|
|
||||
use crate::symbols::Symbol;
|
|
||||
use crate::to_artifact::ToArtifact;
|
|
||||
use crate::{ResourceLocator, Setup, SymbolBuilder};
|
|
||||
use std::cell::RefCell;
|
|
||||
use std::error::Error;
|
|
||||
use std::fmt::Debug;
|
|
||||
use std::rc::Rc;
|
|
||||
|
|
||||
struct TestSymbolRunner {
|
|
||||
count: Rc<RefCell<usize>>,
|
|
||||
}
|
|
||||
|
|
||||
impl SymbolRunner for TestSymbolRunner {
|
|
||||
fn run_symbol<S: Symbol + Debug>(
|
|
||||
&self,
|
|
||||
symbol: &S,
|
|
||||
force: bool,
|
|
||||
) -> Result<bool, Box<dyn Error>> {
|
|
||||
let run = force || !symbol.target_reached()?;
|
|
||||
if run {
|
|
||||
*self.count.borrow_mut() += 1;
|
|
||||
}
|
|
||||
Ok(run)
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
#[derive(Debug, PartialEq, Eq, Hash)]
|
|
||||
struct TestResource<T>(&'static str, T);
|
|
||||
impl<T> Resource for TestResource<T> {
|
|
||||
type Artifact = ();
|
|
||||
}
|
|
||||
|
|
||||
#[derive(Debug, Hash, PartialEq, Eq)]
|
|
||||
enum Resources {
|
|
||||
A(TestResource<&'static str>),
|
|
||||
B(TestResource<()>),
|
|
||||
}
|
|
||||
impl From<TestResource<&'static str>> for Resources {
|
|
||||
fn from(from: TestResource<&'static str>) -> Self {
|
|
||||
Self::A(from)
|
|
||||
}
|
|
||||
}
|
|
||||
impl From<TestResource<()>> for Resources {
|
|
||||
fn from(from: TestResource<()>) -> Self {
|
|
||||
Self::B(from)
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
impl BorrowResource<TestResource<&'static str>> for Resources {
|
|
||||
fn borrow_resource(&self) -> Option<&TestResource<&'static str>> {
|
|
||||
match self {
|
|
||||
Self::A(a) => Some(a),
|
|
||||
_ => None,
|
|
||||
}
|
|
||||
}
|
|
||||
}
|
|
||||
impl BorrowResource<TestResource<()>> for Resources {
|
|
||||
fn borrow_resource(&self) -> Option<&TestResource<()>> {
|
|
||||
match self {
|
|
||||
Self::B(b) => Some(b),
|
|
||||
_ => None,
|
|
||||
}
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
struct TestResourceLocator;
|
|
||||
impl<T> ResourceLocator<TestResource<T>> for TestResourceLocator {
|
|
||||
type Prerequisites = ();
|
|
||||
fn locate(_resource: &TestResource<T>) -> (<TestResource<T> as ToArtifact>::Artifact, ()) {
|
|
||||
((), ())
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
struct TestSymbolBuilder;
|
|
||||
impl SymbolBuilder<TestResource<&'static str>> for TestSymbolBuilder {
|
|
||||
type Symbol = TestSymbol;
|
|
||||
type Prerequisites = TestResource<()>;
|
|
||||
|
|
||||
fn prerequisites(resource: &TestResource<&'static str>) -> Self::Prerequisites {
|
|
||||
TestResource(resource.1, ())
|
|
||||
}
|
|
||||
fn create(
|
|
||||
resource: &TestResource<&'static str>,
|
|
||||
(): &(),
|
|
||||
_inputs: <Self::Prerequisites as ToArtifact>::Artifact,
|
|
||||
) -> Self::Symbol {
|
|
||||
TestSymbol {
|
|
||||
reached: resource.0.chars().next().unwrap().is_uppercase(),
|
|
||||
}
|
|
||||
}
|
|
||||
}
|
|
||||
impl SymbolBuilder<TestResource<()>> for TestSymbolBuilder {
|
|
||||
type Symbol = TestSymbol;
|
|
||||
type Prerequisites = ();
|
|
||||
|
|
||||
fn prerequisites(_resource: &TestResource<()>) -> Self::Prerequisites {}
|
|
||||
fn create(resource: &TestResource<()>, (): &(), (): ()) -> Self::Symbol {
|
|
||||
TestSymbol {
|
|
||||
reached: resource.0.chars().next().unwrap().is_uppercase(),
|
|
||||
}
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
#[derive(Debug)]
|
|
||||
struct TestSymbol {
|
|
||||
reached: bool,
|
|
||||
}
|
|
||||
impl Symbol for TestSymbol {
|
|
||||
fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
|
|
||||
Ok(self.reached)
|
|
||||
}
|
|
||||
fn execute(&self) -> Result<(), Box<dyn Error>> {
|
|
||||
Ok(())
|
|
||||
}
|
|
||||
}
|
|
||||
|
|
||||
fn get_setup() -> (
|
|
||||
Rc<RefCell<usize>>,
|
|
||||
Setup<TestSymbolRunner, TestResourceLocator, Resources, TestSymbolBuilder>,
|
|
||||
) {
|
|
||||
let count = Rc::new(RefCell::new(0));
|
|
||||
let runner = TestSymbolRunner {
|
|
||||
count: Rc::clone(&count),
|
|
||||
};
|
|
||||
(count, Setup::new_with(runner))
|
|
||||
}
|
|
||||
|
|
||||
#[test]
|
|
||||
fn correctly_uses_force() {
|
|
||||
let (count, mut setup) = get_setup();
|
|
||||
setup.add(TestResource("A", "b")).unwrap();
|
|
||||
assert_eq!(*count.borrow(), 2);
|
|
||||
setup.add(TestResource("A", "b")).unwrap();
|
|
||||
assert_eq!(*count.borrow(), 2);
|
|
||||
|
|
||||
let (count, mut setup) = get_setup();
|
|
||||
setup.add(TestResource("A", "B")).unwrap();
|
|
||||
assert_eq!(*count.borrow(), 0);
|
|
||||
}
|
|
||||
|
|
||||
#[test]
|
|
||||
fn correctly_handles_symbol_tuples() {
|
|
||||
let (count, setup) = get_setup();
|
|
||||
setup
|
|
||||
.run_symbol(
|
|
||||
(TestSymbol { reached: false }, TestSymbol { reached: false }),
|
|
||||
false,
|
|
||||
)
|
|
||||
.unwrap();
|
|
||||
assert_eq!(*count.borrow(), 2);
|
|
||||
|
|
||||
let (count, setup) = get_setup();
|
|
||||
setup
|
|
||||
.run_symbol(
|
|
||||
(TestSymbol { reached: true }, TestSymbol { reached: false }),
|
|
||||
false,
|
|
||||
)
|
|
||||
.unwrap();
|
|
||||
assert_eq!(*count.borrow(), 1);
|
|
||||
|
|
||||
// An unreached symbol forces all further symbols
|
|
||||
let (count, setup) = get_setup();
|
|
||||
setup
|
|
||||
.run_symbol(
|
|
||||
(TestSymbol { reached: false }, TestSymbol { reached: true }),
|
|
||||
false,
|
|
||||
)
|
|
||||
.unwrap();
|
|
||||
assert_eq!(*count.borrow(), 2);
|
|
||||
|
|
||||
let (count, setup) = get_setup();
|
|
||||
setup
|
|
||||
.run_symbol(
|
|
||||
(TestSymbol { reached: true }, TestSymbol { reached: true }),
|
|
||||
false,
|
|
||||
)
|
|
||||
.unwrap();
|
|
||||
assert_eq!(*count.borrow(), 0);
|
|
||||
|
|
||||
let (count, setup) = get_setup();
|
|
||||
setup
|
|
||||
.run_symbol(
|
|
||||
(TestSymbol { reached: true }, TestSymbol { reached: true }),
|
|
||||
true,
|
|
||||
)
|
|
||||
.unwrap();
|
|
||||
assert_eq!(*count.borrow(), 2);
|
|
||||
}
|
|
||||
}
|
|
||||
@ -0,0 +1,191 @@ |
|||||
|
use super::runnable::Runnable;
|
||||
|
use super::util::{AddResult, AddableResource};
|
||||
|
use super::Setup;
|
||||
|
use super::SymbolRunner;
|
||||
|
use crate::async_utils::try_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) -> AddResult<X>;
|
||||
|
}
|
||||
|
|
||||
|
macro_rules! add_generic {
|
||||
|
( $($name:ident)* ) => (
|
||||
|
#[async_trait(?Send)]
|
||||
|
#[allow(non_snake_case)]
|
||||
|
impl<SR: 'static, _L: 'static, _B: 'static, LOG: 'static + Logger, Rs: 'static + Hash + Eq, As: 'static + Clone, $($name: AddableResource,)*>
|
||||
|
AddGeneric<($($name,)*)> for Setup<SR, LOG, _L, _B, Rs, As>
|
||||
|
where
|
||||
|
$(
|
||||
|
RegularSetupCore<SR, _L, _B>: SetupCore<$name, Self>,
|
||||
|
As: FromArtifact<$name>,
|
||||
|
Rs: FromResource<$name>,
|
||||
|
$name::Artifact: Clone |
||||
|
),*
|
||||
|
{
|
||||
|
#[allow(unused)]
|
||||
|
async fn add_generic(&self, ($($name,)*): ($($name,)*)) -> Result<(($($name::Artifact,)*), bool), Box<dyn Error>>
|
||||
|
{
|
||||
|
let x: Result<_, Box<dyn Error>> = try_join!($(self.add_async($name, false),)*);
|
||||
|
let ($($name,)*) = x?;
|
||||
|
Ok((($($name.0,)*), false $(|| $name.1)*))
|
||||
|
}
|
||||
|
}
|
||||
|
);
|
||||
|
}
|
||||
|
|
||||
|
for_each_tuple!(add_generic);
|
||||
|
|
||||
|
// This is for self-referential T
|
||||
|
// FIXME: Wait for specialization
|
||||
|
#[async_trait(?Send)]
|
||||
|
impl<
|
||||
|
SR: 'static + SymbolRunner,
|
||||
|
LOG: 'static + Logger,
|
||||
|
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, LOG, 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>) -> AddResult<Option<T>> {
|
||||
|
Ok(match r {
|
||||
|
Some(r) => {
|
||||
|
let (result, did_run) = self.add_async(r, false).await?;
|
||||
|
(Some(result), did_run)
|
||||
|
}
|
||||
|
None => (None, false),
|
||||
|
})
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
#[async_trait(?Send)]
|
||||
|
impl<
|
||||
|
LOG: 'static + Logger,
|
||||
|
T: AddableResource,
|
||||
|
Rs: 'static + Hash + Eq + FromResource<T>,
|
||||
|
As: 'static + FromArtifact<T> + Clone,
|
||||
|
SR: 'static,
|
||||
|
L: 'static,
|
||||
|
B: 'static,
|
||||
|
> AddGeneric<T> for Setup<SR, LOG, L, B, Rs, As>
|
||||
|
where
|
||||
|
T::Artifact: Clone,
|
||||
|
RegularSetupCore<SR, L, B>: 'static + SetupCore<T, Self>,
|
||||
|
{
|
||||
|
async fn add_generic(&self, r: T) -> AddResult<T> {
|
||||
|
self.add_async(r, false).await
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
#[async_trait(?Send)]
|
||||
|
pub trait SetupCore<R: AddableResource, S> {
|
||||
|
async fn add<LOG: Logger, RR: AsRef<R>>(
|
||||
|
&self,
|
||||
|
setup: &S,
|
||||
|
parent_logger: &LOG,
|
||||
|
resource: RR,
|
||||
|
force_run: bool,
|
||||
|
) -> AddResult<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<LOG: Logger, RR: AsRef<R>>(
|
||||
|
&self,
|
||||
|
setup: &S,
|
||||
|
parent_logger: &LOG,
|
||||
|
resource: RR,
|
||||
|
force_run: bool,
|
||||
|
) -> AddResult<R> {
|
||||
|
let resource = resource.as_ref();
|
||||
|
let logger = StoringLogger::new();
|
||||
|
logger.write(4, format!("Adding {:?} ... ", resource));
|
||||
|
let result = {
|
||||
|
logger.trace(format!(" (force_run is {})", force_run));
|
||||
|
let (location, location_prereqs) = L::locate(resource);
|
||||
|
logger.trace(format!("Adding location prereqs for {:?}", resource));
|
||||
|
let (_, location_prereqs_did_run) = setup.add_generic(location_prereqs).await?;
|
||||
|
logger.trace(format!(
|
||||
|
"Location prereqs for {:?} did_run: {}",
|
||||
|
resource, location_prereqs_did_run
|
||||
|
));
|
||||
|
logger.trace(format!("Adding implementation prereqs for {:?}", resource));
|
||||
|
let (prereqs, prereqs_did_run) = setup.add_generic(B::prerequisites(resource)).await?;
|
||||
|
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 = implementation
|
||||
|
.run(
|
||||
|
&self.symbol_runner,
|
||||
|
&logger,
|
||||
|
force_run || location_prereqs_did_run || prereqs_did_run,
|
||||
|
)
|
||||
|
.await?;
|
||||
|
Ok((location, did_run))
|
||||
|
};
|
||||
|
logger.write(4, "done.");
|
||||
|
let max_level = if result.is_err() { 5 } else { 3 };
|
||||
|
if parent_logger.put(logger.release().into_iter().filter(|e| e.0 <= max_level)) == 0 {
|
||||
|
parent_logger.write(3, ".");
|
||||
|
}
|
||||
|
result
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
#[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.debug(format!("Directly running {:?} ...", symbol));
|
||||
|
let result = self.symbol_runner.run_symbol(symbol, &logger, force).await;
|
||||
|
logger.debug("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
|
||||
|
}
|
||||
|
}
|
||||
@ -0,0 +1,10 @@ |
|||||
|
mod core;
|
||||
|
mod util;
|
||||
|
pub use util::{AddResult, AddableResource};
|
||||
|
mod symbol_runner;
|
||||
|
pub use symbol_runner::{
|
||||
|
DrySymbolRunner, InitializingSymbolRunner, ReportingSymbolRunner, SymbolRunner,
|
||||
|
};
|
||||
|
mod runnable;
|
||||
|
mod setup;
|
||||
|
pub use setup::Setup;
|
||||
@ -0,0 +1,193 @@ |
|||||
|
use super::SymbolRunner;
|
||||
|
use crate::loggers::Logger;
|
||||
|
use crate::symbols::Symbol;
|
||||
|
use async_trait::async_trait;
|
||||
|
use std::error::Error;
|
||||
|
use std::fmt::Debug;
|
||||
|
|
||||
|
#[async_trait(?Send)]
|
||||
|
pub trait Runnable {
|
||||
|
async fn run<R: SymbolRunner, L: Logger>(
|
||||
|
&self,
|
||||
|
runner: &R,
|
||||
|
logger: &L,
|
||||
|
force: bool,
|
||||
|
) -> Result<bool, Box<dyn Error>>;
|
||||
|
}
|
||||
|
|
||||
|
#[async_trait(?Send)]
|
||||
|
impl<S> Runnable for S
|
||||
|
where
|
||||
|
Self: Symbol + Debug,
|
||||
|
{
|
||||
|
async fn run<R: SymbolRunner, L: Logger>(
|
||||
|
&self,
|
||||
|
runner: &R,
|
||||
|
logger: &L,
|
||||
|
force: bool,
|
||||
|
) -> Result<bool, Box<dyn Error>> {
|
||||
|
runner.run_symbol(self, logger, force).await
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
macro_rules! runnable_for_tuple {
|
||||
|
( $($name:ident)* ) => (
|
||||
|
#[async_trait(?Send)]
|
||||
|
#[allow(non_snake_case)]
|
||||
|
impl<$($name: Symbol + Debug,)*> Runnable for ($($name,)*) {
|
||||
|
#[allow(unused)]
|
||||
|
async fn run<_R: SymbolRunner, _L: Logger>(&self, runner: &_R, logger: &_L, force: bool) -> Result<bool, Box<dyn Error>> {
|
||||
|
let ($($name,)*) = self;
|
||||
|
let mut result = false;
|
||||
|
$(result = runner.run_symbol($name, logger, force || result).await? || result;)*
|
||||
|
Ok(result)
|
||||
|
}
|
||||
|
}
|
||||
|
);
|
||||
|
}
|
||||
|
|
||||
|
for_each_tuple!(runnable_for_tuple);
|
||||
|
|
||||
|
#[cfg(test)]
|
||||
|
mod test {
|
||||
|
use super::Runnable;
|
||||
|
use crate::async_utils::run;
|
||||
|
use crate::loggers::{Logger, StoringLogger};
|
||||
|
use crate::symbols::Symbol;
|
||||
|
use crate::SymbolRunner;
|
||||
|
use async_trait::async_trait;
|
||||
|
use std::cell::RefCell;
|
||||
|
use std::error::Error;
|
||||
|
use std::fmt::Debug;
|
||||
|
use std::rc::Rc;
|
||||
|
|
||||
|
#[derive(Debug)]
|
||||
|
struct DummySymbol<T, E> {
|
||||
|
_target_reached: RefCell<T>,
|
||||
|
_execute: RefCell<E>,
|
||||
|
}
|
||||
|
|
||||
|
#[async_trait(?Send)]
|
||||
|
impl<
|
||||
|
E: Iterator<Item = Result<(), Box<dyn Error>>>,
|
||||
|
T: Iterator<Item = Result<bool, Box<dyn Error>>>,
|
||||
|
> Symbol for DummySymbol<T, E>
|
||||
|
{
|
||||
|
async fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
|
||||
|
self._target_reached.borrow_mut().next().unwrap()
|
||||
|
}
|
||||
|
async fn execute(&self) -> Result<(), Box<dyn Error>> {
|
||||
|
self._execute.borrow_mut().next().unwrap()
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
impl<
|
||||
|
E: Iterator<Item = Result<(), Box<dyn Error>>>,
|
||||
|
T: Iterator<Item = Result<bool, Box<dyn Error>>>,
|
||||
|
> DummySymbol<T, E>
|
||||
|
{
|
||||
|
fn new<
|
||||
|
IE: IntoIterator<IntoIter = E, Item = Result<(), Box<dyn Error>>>,
|
||||
|
IT: IntoIterator<IntoIter = T, Item = Result<bool, Box<dyn Error>>>,
|
||||
|
>(
|
||||
|
target_reached: IT,
|
||||
|
execute: IE,
|
||||
|
) -> Self {
|
||||
|
Self {
|
||||
|
_target_reached: RefCell::new(target_reached.into_iter()),
|
||||
|
_execute: RefCell::new(execute.into_iter()),
|
||||
|
}
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
struct TestSymbolRunner {
|
||||
|
count: Rc<RefCell<usize>>,
|
||||
|
}
|
||||
|
|
||||
|
fn get_runner() -> (Rc<RefCell<usize>>, TestSymbolRunner) {
|
||||
|
let count = Rc::new(RefCell::new(0));
|
||||
|
let runner = TestSymbolRunner {
|
||||
|
count: Rc::clone(&count),
|
||||
|
};
|
||||
|
(count, runner)
|
||||
|
}
|
||||
|
|
||||
|
#[async_trait(?Send)]
|
||||
|
impl SymbolRunner for TestSymbolRunner {
|
||||
|
async fn run_symbol<S: Symbol + Debug, L: Logger>(
|
||||
|
&self,
|
||||
|
symbol: &S,
|
||||
|
logger: &L,
|
||||
|
force: bool,
|
||||
|
) -> Result<bool, Box<dyn Error>> {
|
||||
|
let run = force || !symbol.target_reached().await?;
|
||||
|
if run {
|
||||
|
*self.count.borrow_mut() += 1;
|
||||
|
}
|
||||
|
Ok(run)
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
fn run_symbol(
|
||||
|
runnable: impl Runnable,
|
||||
|
force: bool,
|
||||
|
) -> (Rc<RefCell<usize>>, Result<bool, Box<dyn Error>>) {
|
||||
|
let (count, runner) = get_runner();
|
||||
|
let res = run(runnable.run(&runner, &StoringLogger::new(), force));
|
||||
|
(count, res)
|
||||
|
}
|
||||
|
|
||||
|
#[test]
|
||||
|
fn correctly_handles_symbol_tuples() {
|
||||
|
let (count, res) = run_symbol(
|
||||
|
(
|
||||
|
DummySymbol::new(vec![Ok(false)], vec![Ok(())]),
|
||||
|
DummySymbol::new(vec![Ok(false)], vec![Ok(())]),
|
||||
|
),
|
||||
|
false,
|
||||
|
);
|
||||
|
res.unwrap();
|
||||
|
assert_eq!(*count.borrow(), 2);
|
||||
|
|
||||
|
let (count, res) = run_symbol(
|
||||
|
(
|
||||
|
DummySymbol::new(vec![Ok(true)], vec![Ok(())]),
|
||||
|
DummySymbol::new(vec![Ok(false)], vec![Ok(())]),
|
||||
|
),
|
||||
|
false,
|
||||
|
);
|
||||
|
res.unwrap();
|
||||
|
assert_eq!(*count.borrow(), 1);
|
||||
|
|
||||
|
// An unreached symbol forces all further symbols
|
||||
|
let (count, res) = run_symbol(
|
||||
|
(
|
||||
|
DummySymbol::new(vec![Ok(false)], vec![Ok(())]),
|
||||
|
DummySymbol::new(vec![Ok(true)], vec![Ok(())]),
|
||||
|
),
|
||||
|
false,
|
||||
|
);
|
||||
|
res.unwrap();
|
||||
|
assert_eq!(*count.borrow(), 2);
|
||||
|
|
||||
|
let (count, res) = run_symbol(
|
||||
|
(
|
||||
|
DummySymbol::new(vec![Ok(true)], vec![Ok(())]),
|
||||
|
DummySymbol::new(vec![Ok(true)], vec![Ok(())]),
|
||||
|
),
|
||||
|
false,
|
||||
|
);
|
||||
|
res.unwrap();
|
||||
|
assert_eq!(*count.borrow(), 0);
|
||||
|
|
||||
|
let (count, res) = run_symbol(
|
||||
|
(
|
||||
|
DummySymbol::new(vec![Ok(true)], vec![Ok(())]),
|
||||
|
DummySymbol::new(vec![Ok(true)], vec![Ok(())]),
|
||||
|
),
|
||||
|
true,
|
||||
|
);
|
||||
|
res.unwrap();
|
||||
|
assert_eq!(*count.borrow(), 2);
|
||||
|
}
|
||||
|
}
|
||||
@ -0,0 +1,300 @@ |
|||||
|
use super::core::{RegularSetupCore, SetupCore};
|
||||
|
use super::runnable::Runnable;
|
||||
|
use super::util::{AddResult, AddableResource};
|
||||
|
use super::SymbolRunner;
|
||||
|
use crate::async_utils::run;
|
||||
|
use crate::loggers::Logger;
|
||||
|
use crate::resources::{DefaultArtifacts, DefaultResources, FromArtifact, FromResource};
|
||||
|
use crate::{DefaultBuilder, DefaultLocator};
|
||||
|
use futures::future::FutureExt;
|
||||
|
use futures::future::Shared;
|
||||
|
use std::cell::{RefCell, RefMut};
|
||||
|
use std::collections::HashMap;
|
||||
|
use std::error::Error;
|
||||
|
use std::future::Future;
|
||||
|
use std::hash::Hash;
|
||||
|
use std::pin::Pin;
|
||||
|
use std::rc::Rc;
|
||||
|
|
||||
|
type Cache<Rs, As> = HashMap<Rs, Shared<Pin<Box<dyn Future<Output = (As, bool)>>>>>;
|
||||
|
|
||||
|
#[derive(Debug)]
|
||||
|
struct SetupInner<CORE, LOG, Rs, As> {
|
||||
|
core: CORE,
|
||||
|
logger: LOG,
|
||||
|
resources: RefCell<Cache<Rs, As>>,
|
||||
|
}
|
||||
|
|
||||
|
#[derive(Debug)]
|
||||
|
pub struct Setup<
|
||||
|
SR,
|
||||
|
LOG,
|
||||
|
L = DefaultLocator,
|
||||
|
B = DefaultBuilder,
|
||||
|
Rs = DefaultResources<'static, &'static str>,
|
||||
|
As = DefaultArtifacts<'static, &'static str>,
|
||||
|
>(Rc<SetupInner<RegularSetupCore<SR, L, B>, LOG, Rs, As>>);
|
||||
|
|
||||
|
// https://github.com/rust-lang/rust/issues/27336
|
||||
|
impl<SR, LOG> Setup<SR, LOG> {
|
||||
|
pub fn new(symbol_runner: SR, logger: LOG) -> Self {
|
||||
|
Self::new_with(symbol_runner, logger)
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
impl<L, B, As, SR, LOG, Rs: Hash + Eq> Setup<SR, LOG, L, B, Rs, As> {
|
||||
|
pub fn new_with(symbol_runner: SR, logger: LOG) -> Self {
|
||||
|
Self(Rc::new(SetupInner {
|
||||
|
core: RegularSetupCore::new(symbol_runner),
|
||||
|
logger,
|
||||
|
resources: RefCell::default(),
|
||||
|
}))
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
impl<
|
||||
|
L: 'static,
|
||||
|
B: 'static,
|
||||
|
SR: 'static,
|
||||
|
LOG: 'static + Logger,
|
||||
|
Rs: Hash + Eq + 'static,
|
||||
|
As: 'static,
|
||||
|
> Setup<SR, LOG, L, B, Rs, As>
|
||||
|
{
|
||||
|
fn borrow_resources(&self) -> RefMut<'_, Cache<Rs, As>> {
|
||||
|
self.0.resources.borrow_mut()
|
||||
|
}
|
||||
|
|
||||
|
pub(super) async fn add_async<R: AddableResource>(
|
||||
|
&self,
|
||||
|
resource: R,
|
||||
|
force_run: bool,
|
||||
|
) -> AddResult<R>
|
||||
|
where
|
||||
|
Rs: FromResource<R>,
|
||||
|
As: FromArtifact<R> + Clone,
|
||||
|
R::Artifact: Clone,
|
||||
|
RegularSetupCore<SR, L, B>: SetupCore<R, Self>,
|
||||
|
{
|
||||
|
let (storable_resource, weak_resource) = Rs::from_resource(resource);
|
||||
|
let mut resources = self.borrow_resources();
|
||||
|
if let Some(future) = resources.remove(&storable_resource) {
|
||||
|
assert!(
|
||||
|
!force_run,
|
||||
|
"Forcing to run an already-added resource is a logical error"
|
||||
|
);
|
||||
|
resources.insert(storable_resource, future.clone());
|
||||
|
drop(resources);
|
||||
|
Ok(future.await)
|
||||
|
} else {
|
||||
|
let inner_weak = Rc::downgrade(&self.0);
|
||||
|
let future = Box::pin(async move {
|
||||
|
let this = Self(inner_weak.upgrade().expect("Dangling!"));
|
||||
|
let resource = weak_resource.upgrade().expect("Dangling!");
|
||||
|
// Need to convert Box<Error> to String for Clone for Shared
|
||||
|
this
|
||||
|
.0
|
||||
|
.core
|
||||
|
.add(&this, &this.0.logger, resource, force_run)
|
||||
|
.await
|
||||
|
.map(|(t, did_run)| (As::from_artifact(t), did_run))
|
||||
|
.map_err(|e| e.to_string())
|
||||
|
})
|
||||
|
.shared();
|
||||
|
let future_clone = future.clone();
|
||||
|
resources.insert(
|
||||
|
storable_resource,
|
||||
|
(Box::pin(async move { future_clone.await.unwrap() })
|
||||
|
as Pin<Box<dyn Future<Output = (As, bool)>>>)
|
||||
|
.shared(),
|
||||
|
);
|
||||
|
drop(resources);
|
||||
|
future.await.map_err(|e| e.into())
|
||||
|
}
|
||||
|
.map(|(t, did_run)| (t.into_artifact(), did_run))
|
||||
|
}
|
||||
|
|
||||
|
//
|
||||
|
// Legacy
|
||||
|
//
|
||||
|
pub fn add<R: AddableResource>(&self, resource: R) -> AddResult<R>
|
||||
|
where
|
||||
|
RegularSetupCore<SR, L, B>: SetupCore<R, Self>,
|
||||
|
Rs: FromResource<R>,
|
||||
|
As: FromArtifact<R> + Clone,
|
||||
|
R::Artifact: Clone,
|
||||
|
{
|
||||
|
run(self.add_async(resource, false))
|
||||
|
}
|
||||
|
|
||||
|
pub fn add_force<R: AddableResource>(&self, resource: R, force_run: bool) -> AddResult<R>
|
||||
|
where
|
||||
|
RegularSetupCore<SR, L, B>: SetupCore<R, Self>,
|
||||
|
Rs: FromResource<R>,
|
||||
|
As: FromArtifact<R> + Clone,
|
||||
|
R::Artifact: Clone,
|
||||
|
{
|
||||
|
run(self.add_async(resource, force_run))
|
||||
|
}
|
||||
|
|
||||
|
pub fn run_symbol<S: Runnable>(&self, symbol: S, force: bool) -> Result<bool, Box<dyn Error>>
|
||||
|
where
|
||||
|
RegularSetupCore<SR, L, B>: SymbolRunner,
|
||||
|
{
|
||||
|
run(symbol.run(&self.0.core, &self.0.logger, force))
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
#[cfg(test)]
|
||||
|
mod test {
|
||||
|
use super::SymbolRunner;
|
||||
|
use crate::loggers::{Logger, StoringLogger};
|
||||
|
use crate::resources::{FromArtifact, FromResource, Resource};
|
||||
|
use crate::symbols::Symbol;
|
||||
|
use crate::to_artifact::ToArtifact;
|
||||
|
use crate::{ImplementationBuilder, ResourceLocator, Setup};
|
||||
|
use async_trait::async_trait;
|
||||
|
use std::cell::RefCell;
|
||||
|
use std::error::Error;
|
||||
|
use std::fmt::Debug;
|
||||
|
use std::rc::{Rc, Weak};
|
||||
|
|
||||
|
struct TestSymbolRunner {
|
||||
|
count: Rc<RefCell<usize>>,
|
||||
|
}
|
||||
|
|
||||
|
#[async_trait(?Send)]
|
||||
|
impl SymbolRunner for TestSymbolRunner {
|
||||
|
async fn run_symbol<S: Symbol + Debug, L: Logger>(
|
||||
|
&self,
|
||||
|
symbol: &S,
|
||||
|
logger: &L,
|
||||
|
force: bool,
|
||||
|
) -> Result<bool, Box<dyn Error>> {
|
||||
|
let run = force || !symbol.target_reached().await?;
|
||||
|
if run {
|
||||
|
*self.count.borrow_mut() += 1;
|
||||
|
}
|
||||
|
Ok(run)
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
#[derive(Debug, PartialEq, Eq, Hash)]
|
||||
|
struct TestResource<T>(&'static str, T);
|
||||
|
impl<T> Resource for TestResource<T> {
|
||||
|
type Artifact = ();
|
||||
|
}
|
||||
|
|
||||
|
#[derive(Debug, Hash, PartialEq, Eq)]
|
||||
|
enum Resources {
|
||||
|
A(Rc<TestResource<&'static str>>),
|
||||
|
B(Rc<TestResource<()>>),
|
||||
|
}
|
||||
|
impl FromResource<TestResource<&'static str>> for Resources {
|
||||
|
fn from_resource(from: TestResource<&'static str>) -> (Self, Weak<TestResource<&'static str>>) {
|
||||
|
let inner = Rc::new(from);
|
||||
|
(Self::A(Rc::clone(&inner)), Rc::downgrade(&inner))
|
||||
|
}
|
||||
|
}
|
||||
|
impl FromResource<TestResource<()>> for Resources {
|
||||
|
fn from_resource(from: TestResource<()>) -> (Self, Weak<TestResource<()>>) {
|
||||
|
let inner = Rc::new(from);
|
||||
|
(Self::B(Rc::clone(&inner)), Rc::downgrade(&inner))
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
#[derive(Clone)]
|
||||
|
struct Artifacts;
|
||||
|
impl<V> FromArtifact<TestResource<V>> for Artifacts {
|
||||
|
fn from_artifact(from: ()) -> Self {
|
||||
|
Self
|
||||
|
}
|
||||
|
fn into_artifact(self) -> () {
|
||||
|
()
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
struct TestResourceLocator;
|
||||
|
impl<T> ResourceLocator<TestResource<T>> for TestResourceLocator {
|
||||
|
type Prerequisites = ();
|
||||
|
fn locate(_resource: &TestResource<T>) -> (<TestResource<T> as ToArtifact>::Artifact, ()) {
|
||||
|
((), ())
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
struct TestImplementationBuilder;
|
||||
|
impl ImplementationBuilder<TestResource<&'static str>> for TestImplementationBuilder {
|
||||
|
type Implementation = TestSymbol;
|
||||
|
type Prerequisites = TestResource<()>;
|
||||
|
|
||||
|
fn prerequisites(resource: &TestResource<&'static str>) -> Self::Prerequisites {
|
||||
|
TestResource(resource.1, ())
|
||||
|
}
|
||||
|
fn create(
|
||||
|
resource: &TestResource<&'static str>,
|
||||
|
(): &(),
|
||||
|
_inputs: <Self::Prerequisites as ToArtifact>::Artifact,
|
||||
|
) -> Self::Implementation {
|
||||
|
TestSymbol {
|
||||
|
reached: resource.0.chars().next().unwrap().is_uppercase(),
|
||||
|
}
|
||||
|
}
|
||||
|
}
|
||||
|
impl ImplementationBuilder<TestResource<()>> for TestImplementationBuilder {
|
||||
|
type Implementation = TestSymbol;
|
||||
|
type Prerequisites = ();
|
||||
|
|
||||
|
fn prerequisites(_resource: &TestResource<()>) -> Self::Prerequisites {}
|
||||
|
fn create(resource: &TestResource<()>, (): &(), (): ()) -> Self::Implementation {
|
||||
|
TestSymbol {
|
||||
|
reached: resource.0.chars().next().unwrap().is_uppercase(),
|
||||
|
}
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
#[derive(Debug)]
|
||||
|
struct TestSymbol {
|
||||
|
reached: bool,
|
||||
|
}
|
||||
|
|
||||
|
#[async_trait(?Send)]
|
||||
|
impl Symbol for TestSymbol {
|
||||
|
async fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
|
||||
|
Ok(self.reached)
|
||||
|
}
|
||||
|
async fn execute(&self) -> Result<(), Box<dyn Error>> {
|
||||
|
Ok(())
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
fn get_setup() -> (
|
||||
|
Rc<RefCell<usize>>,
|
||||
|
Setup<
|
||||
|
TestSymbolRunner,
|
||||
|
StoringLogger,
|
||||
|
TestResourceLocator,
|
||||
|
TestImplementationBuilder,
|
||||
|
Resources,
|
||||
|
Artifacts,
|
||||
|
>,
|
||||
|
) {
|
||||
|
let count = Rc::new(RefCell::new(0));
|
||||
|
let runner = TestSymbolRunner {
|
||||
|
count: Rc::clone(&count),
|
||||
|
};
|
||||
|
(count, Setup::new_with(runner, StoringLogger::new()))
|
||||
|
}
|
||||
|
|
||||
|
#[test]
|
||||
|
fn correctly_uses_force() {
|
||||
|
let (count, setup) = get_setup();
|
||||
|
setup.add(TestResource("A", "b")).unwrap();
|
||||
|
assert_eq!(*count.borrow(), 2);
|
||||
|
setup.add(TestResource("A", "b")).unwrap();
|
||||
|
assert_eq!(*count.borrow(), 2);
|
||||
|
|
||||
|
let (count, setup) = get_setup();
|
||||
|
setup.add(TestResource("A", "B")).unwrap();
|
||||
|
assert_eq!(*count.borrow(), 0);
|
||||
|
}
|
||||
|
}
|
||||
@ -0,0 +1,318 @@ |
|||||
|
use crate::loggers::Logger;
|
||||
|
use crate::symbols::Symbol;
|
||||
|
use async_trait::async_trait;
|
||||
|
use std::error::Error;
|
||||
|
use std::fmt;
|
||||
|
use std::fmt::Debug;
|
||||
|
|
||||
|
#[async_trait(?Send)]
|
||||
|
pub trait SymbolRunner {
|
||||
|
async fn run_symbol<S: Symbol + Debug, L: Logger>(
|
||||
|
&self,
|
||||
|
symbol: &S,
|
||||
|
logger: &L,
|
||||
|
force: bool,
|
||||
|
) -> Result<bool, Box<dyn Error>>;
|
||||
|
}
|
||||
|
|
||||
|
#[derive(Debug)]
|
||||
|
pub enum SymbolRunError {
|
||||
|
Symbol(Box<dyn Error>),
|
||||
|
ExecuteDidNotReach(()),
|
||||
|
}
|
||||
|
|
||||
|
impl Error for SymbolRunError {
|
||||
|
fn cause(&self) -> Option<&dyn Error> {
|
||||
|
match self {
|
||||
|
Self::Symbol(ref e) => Some(&**e),
|
||||
|
Self::ExecuteDidNotReach(_) => None,
|
||||
|
}
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
impl fmt::Display for SymbolRunError {
|
||||
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
|
match self {
|
||||
|
Self::Symbol(ref e) => write!(f, "{}", e),
|
||||
|
Self::ExecuteDidNotReach(_) => write!(f, "Target not reached after executing symbol"),
|
||||
|
}
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
#[derive(Clone, Debug, Default)]
|
||||
|
pub struct InitializingSymbolRunner;
|
||||
|
|
||||
|
impl InitializingSymbolRunner {
|
||||
|
pub fn new() -> Self {
|
||||
|
Self
|
||||
|
}
|
||||
|
|
||||
|
async fn exec_symbol<S: Symbol + Debug, L: Logger>(
|
||||
|
&self,
|
||||
|
symbol: &S,
|
||||
|
logger: &L,
|
||||
|
) -> Result<(), Box<dyn Error>> {
|
||||
|
logger.info(format!("Executing {:?}", symbol));
|
||||
|
symbol.execute().await?;
|
||||
|
let target_reached = symbol.target_reached().await?;
|
||||
|
logger.trace(format!(
|
||||
|
"Symbol reports target_reached: {:?} (should be true)",
|
||||
|
target_reached
|
||||
|
));
|
||||
|
if target_reached {
|
||||
|
Ok(())
|
||||
|
} else {
|
||||
|
Err(Box::new(SymbolRunError::ExecuteDidNotReach(())))
|
||||
|
}
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
#[async_trait(?Send)]
|
||||
|
impl SymbolRunner for InitializingSymbolRunner {
|
||||
|
async fn run_symbol<S: Symbol + Debug, L: Logger>(
|
||||
|
&self,
|
||||
|
symbol: &S,
|
||||
|
logger: &L,
|
||||
|
force: bool,
|
||||
|
) -> Result<bool, Box<dyn Error>> {
|
||||
|
let executed = if force {
|
||||
|
logger.debug("Forcing symbol execution");
|
||||
|
self.exec_symbol(symbol, logger).await?;
|
||||
|
true
|
||||
|
} else {
|
||||
|
let target_reached = symbol.target_reached().await?;
|
||||
|
if target_reached {
|
||||
|
logger.debug(format!("{:?} already reached", symbol));
|
||||
|
} else {
|
||||
|
logger.trace(format!(
|
||||
|
"Symbol reports target_reached: {:?}",
|
||||
|
target_reached
|
||||
|
));
|
||||
|
self.exec_symbol(symbol, logger).await?;
|
||||
|
}
|
||||
|
!target_reached
|
||||
|
};
|
||||
|
Ok(executed)
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
#[derive(Clone, Debug, Default)]
|
||||
|
pub struct DrySymbolRunner;
|
||||
|
|
||||
|
impl DrySymbolRunner {
|
||||
|
pub fn new() -> Self {
|
||||
|
Self
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
#[async_trait(?Send)]
|
||||
|
impl SymbolRunner for DrySymbolRunner {
|
||||
|
async fn run_symbol<S: Symbol + Debug, L: Logger>(
|
||||
|
&self,
|
||||
|
symbol: &S,
|
||||
|
logger: &L,
|
||||
|
force: bool,
|
||||
|
) -> Result<bool, Box<dyn Error>> {
|
||||
|
let would_execute = if force {
|
||||
|
logger.info(format!("Would force-execute {:?}", symbol));
|
||||
|
true
|
||||
|
} else {
|
||||
|
let target_reached = symbol.target_reached().await?;
|
||||
|
logger.debug(format!(
|
||||
|
"Symbol reports target_reached: {:?}",
|
||||
|
target_reached
|
||||
|
));
|
||||
|
if !target_reached {
|
||||
|
logger.info(format!("Would execute {:?}", symbol));
|
||||
|
}
|
||||
|
!target_reached
|
||||
|
};
|
||||
|
Ok(would_execute)
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
#[derive(Clone, Debug)]
|
||||
|
pub struct ReportingSymbolRunner<R>(R);
|
||||
|
|
||||
|
impl<R> ReportingSymbolRunner<R> {
|
||||
|
pub fn new(symbol_runner: R) -> Self {
|
||||
|
Self(symbol_runner)
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
#[async_trait(?Send)]
|
||||
|
impl<R> SymbolRunner for ReportingSymbolRunner<R>
|
||||
|
where
|
||||
|
R: SymbolRunner,
|
||||
|
{
|
||||
|
async fn run_symbol<S: Symbol + Debug, L: Logger>(
|
||||
|
&self,
|
||||
|
symbol: &S,
|
||||
|
logger: &L,
|
||||
|
force: bool,
|
||||
|
) -> Result<bool, Box<dyn Error>> {
|
||||
|
logger.debug(format!("Running symbol {:?}", symbol));
|
||||
|
let res = self.0.run_symbol(symbol, logger, force).await;
|
||||
|
if let Err(ref e) = res {
|
||||
|
logger.info(format!("Failed on {:?} with {}, aborting.", symbol, e))
|
||||
|
} else {
|
||||
|
logger.debug(format!("Successfully finished {:?}", symbol))
|
||||
|
}
|
||||
|
res
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
#[cfg(test)]
|
||||
|
mod test {
|
||||
|
use super::{DrySymbolRunner, InitializingSymbolRunner, ReportingSymbolRunner, SymbolRunner};
|
||||
|
use crate::async_utils::sleep;
|
||||
|
use crate::async_utils::{run, try_join};
|
||||
|
use crate::loggers::StoringLogger;
|
||||
|
use crate::symbols::Symbol;
|
||||
|
use async_trait::async_trait;
|
||||
|
use std::cell::RefCell;
|
||||
|
use std::error::Error;
|
||||
|
use std::fmt;
|
||||
|
use std::fmt::Debug;
|
||||
|
use std::time::Duration;
|
||||
|
|
||||
|
#[derive(Debug, PartialEq, Clone)]
|
||||
|
enum DummySymbolError {
|
||||
|
Error(()),
|
||||
|
}
|
||||
|
|
||||
|
impl Error for DummySymbolError {}
|
||||
|
|
||||
|
impl fmt::Display for DummySymbolError {
|
||||
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
|
write!(f, "Dummy symbol error")
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
#[derive(Debug)]
|
||||
|
struct DummySymbol<T, E> {
|
||||
|
_target_reached: RefCell<T>,
|
||||
|
_execute: RefCell<E>,
|
||||
|
}
|
||||
|
|
||||
|
#[async_trait(?Send)]
|
||||
|
impl<
|
||||
|
E: Iterator<Item = Result<(), Box<dyn Error>>>,
|
||||
|
T: Iterator<Item = Result<bool, Box<dyn Error>>>,
|
||||
|
> Symbol for DummySymbol<T, E>
|
||||
|
{
|
||||
|
async fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
|
||||
|
self._target_reached.borrow_mut().next().unwrap()
|
||||
|
}
|
||||
|
async fn execute(&self) -> Result<(), Box<dyn Error>> {
|
||||
|
self._execute.borrow_mut().next().unwrap()
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
impl<
|
||||
|
E: Iterator<Item = Result<(), Box<dyn Error>>>,
|
||||
|
T: Iterator<Item = Result<bool, Box<dyn Error>>>,
|
||||
|
> DummySymbol<T, E>
|
||||
|
{
|
||||
|
fn new<
|
||||
|
IE: IntoIterator<IntoIter = E, Item = Result<(), Box<dyn Error>>>,
|
||||
|
IT: IntoIterator<IntoIter = T, Item = Result<bool, Box<dyn Error>>>,
|
||||
|
>(
|
||||
|
target_reached: IT,
|
||||
|
execute: IE,
|
||||
|
) -> Self {
|
||||
|
Self {
|
||||
|
_target_reached: RefCell::new(target_reached.into_iter()),
|
||||
|
_execute: RefCell::new(execute.into_iter()),
|
||||
|
}
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
fn run_symbol<S: Symbol + Debug>(s: S) -> Result<bool, Box<dyn Error>> {
|
||||
|
run(InitializingSymbolRunner::new().run_symbol(&s, &StoringLogger::new(), false))
|
||||
|
}
|
||||
|
|
||||
|
#[test]
|
||||
|
fn nothing_needed_to_be_done() {
|
||||
|
let result = run_symbol(DummySymbol::new(vec![Ok(true)], vec![Ok(())]));
|
||||
|
assert!(result.is_ok());
|
||||
|
}
|
||||
|
|
||||
|
#[test]
|
||||
|
fn everything_is_ok() {
|
||||
|
let result = run_symbol(DummySymbol::new(vec![Ok(false), Ok(true)], vec![Ok(())]));
|
||||
|
assert!(result.is_ok());
|
||||
|
}
|
||||
|
|
||||
|
#[test]
|
||||
|
fn executing_did_not_change_state() {
|
||||
|
let result = run_symbol(DummySymbol::new(vec![Ok(false), Ok(false)], vec![Ok(())]));
|
||||
|
assert_eq!(
|
||||
|
result.unwrap_err().to_string(),
|
||||
|
"Target not reached after executing symbol"
|
||||
|
);
|
||||
|
}
|
||||
|
|
||||
|
#[test]
|
||||
|
fn executing_did_not_work() {
|
||||
|
let result = run_symbol(DummySymbol::new(
|
||||
|
vec![Ok(false)],
|
||||
|
vec![Err(Box::new(DummySymbolError::Error(())) as Box<dyn Error>)],
|
||||
|
));
|
||||
|
assert_eq!(result.unwrap_err().to_string(), "Dummy symbol error");
|
||||
|
}
|
||||
|
|
||||
|
#[derive(Debug)]
|
||||
|
struct SleeperSymbol;
|
||||
|
|
||||
|
#[async_trait(?Send)]
|
||||
|
impl Symbol for SleeperSymbol {
|
||||
|
async fn target_reached(&self) -> Result<bool, Box<dyn Error>> {
|
||||
|
sleep(Duration::from_millis(0)).await;
|
||||
|
Ok(true)
|
||||
|
}
|
||||
|
async fn execute(&self) -> Result<(), Box<dyn Error>> {
|
||||
|
unimplemented!();
|
||||
|
}
|
||||
|
}
|
||||
|
|
||||
|
#[test]
|
||||
|
fn actually_support_parallel_execution() {
|
||||
|
run(async {
|
||||
|
let s1 = SleeperSymbol;
|
||||
|
let s2 = DummySymbol::new(vec![Ok(false), Ok(true)], vec![Ok(())]);
|
||||
|
|
||||
|
let l1 = StoringLogger::new();
|
||||
|
let l2 = StoringLogger::new();
|
||||
|
let runner1 = InitializingSymbolRunner::new();
|
||||
|
let result = try_join!(
|
||||
|
runner1.run_symbol(&s1, &l1, false),
|
||||
|
runner1.run_symbol(&s2, &l2, false),
|
||||
|
)
|
||||
|
.unwrap();
|
||||
|
assert_eq!(result, (false, true));
|
||||
|
|
||||
|
let s2 = DummySymbol::new(vec![Ok(false), Ok(true)], vec![Ok(())]);
|
||||
|
let l1 = StoringLogger::new();
|
||||
|
let l2 = StoringLogger::new();
|
||||
|
let runner2 = DrySymbolRunner::new();
|
||||
|
let result = try_join!(
|
||||
|
runner2.run_symbol(&s1, &l1, false),
|
||||
|
runner2.run_symbol(&s2, &l2, false),
|
||||
|
)
|
||||
|
.unwrap();
|
||||
|
assert_eq!(result, (false, true));
|
||||
|
|
||||
|
let s2 = DummySymbol::new(vec![Ok(false), Ok(true)], vec![Ok(())]);
|
||||
|
let l1 = StoringLogger::new();
|
||||
|
let l2 = StoringLogger::new();
|
||||
|
let runner3 = ReportingSymbolRunner::new(runner1);
|
||||
|
let result = try_join!(
|
||||
|
runner3.run_symbol(&s1, &l1, false),
|
||||
|
runner3.run_symbol(&s2, &l2, false),
|
||||
|
)
|
||||
|
.unwrap();
|
||||
|
assert_eq!(result, (false, true));
|
||||
|
});
|
||||
|
}
|
||||
|
}
|
||||
@ -0,0 +1,9 @@ |
|||||
|
use crate::resources::Resource;
|
||||
|
use crate::to_artifact::ToArtifact;
|
||||
|
use std::error::Error;
|
||||
|
use std::fmt::Debug;
|
||||
|
|
||||
|
pub trait AddableResource: 'static + Resource + Debug {}
|
||||
|
impl<R> AddableResource for R where R: 'static + Resource + Debug {}
|
||||
|
|
||||
|
pub type AddResult<R> = Result<(<R as ToArtifact>::Artifact, bool), Box<dyn Error>>;
|
||||
@ -1,4 +1,4 @@ |
|||||
mod checkout;
|
mod checkout;
|
||||
//pub mod submodules;
|
|
||||
|
pub mod submodules;
|
||||
|
|
||||
pub use checkout::Checkout;
|
pub use checkout::Checkout;
|
||||
Write
Preview
Loading…
Cancel
Save
Reference in new issue