Untangle and move around setup structs

src/setup/realizer.rs

@@ -0,0 +1,74 @@
+use super::{Add, AddGeneric, AddResult, AddableResource, Runnable, SymbolRunner};
+use crate::{ImplementationBuilder, ResourceLocator};
+use async_trait::async_trait;
+use slog::{debug, o, trace, Logger};
+use std::fmt::Debug;
+use std::marker::PhantomData;
+use std::rc::{Rc, Weak};
+
+#[derive(Debug)]
+pub struct Realizer<SR, L, B, S> {
+  symbol_runner: Rc<SR>,
+  outer: Weak<S>,
+  phantom: PhantomData<(L, B)>,
+}
+
+impl<SR, L, B, S> Realizer<SR, L, B, S> {
+  pub fn new(symbol_runner: Rc<SR>, outer: Weak<S>) -> Self {
+    Self {
+      symbol_runner,
+      outer,
+      phantom: PhantomData::default(),
+    }
+  }
+}
+
+#[async_trait(?Send)]
+impl<R, SR, L, B, S> Add<R> for Realizer<SR, L, B, S>
+where
+  R: AddableResource,
+  SR: SymbolRunner,
+  L: ResourceLocator<R>,
+  B: ImplementationBuilder<R>,
+  <B as ImplementationBuilder<R>>::Implementation: Runnable + Debug,
+  S: AddGeneric<B::Prerequisites> + AddGeneric<<L as ResourceLocator<R>>::Prerequisites>,
+{
+  async fn add(&self, logger: &Rc<Logger>, resource: Rc<R>, force_run: bool) -> AddResult<R> {
+    let setup = self.outer.upgrade().unwrap();
+    let logger = Rc::new(logger.new(o!("resource" => format!("{resource:?}"))));
+    trace!(logger, "(force_run is {})", force_run);
+    let (location, location_prereqs) = L::locate(&resource);
+    trace!(logger, "Adding location prereqs ...");
+    let (_, location_prereqs_did_run) = (*setup)
+      .add_generic(&logger, location_prereqs, false)
+      .await?;
+    trace!(
+      logger,
+      "Location prereqs did_run: {}",
+      location_prereqs_did_run
+    );
+
+    trace!(logger, "Adding implementation prereqs ...");
+    let (prereqs, prereqs_did_run) = (*setup)
+      .add_generic(&logger, B::prerequisites(&resource), false)
+      .await?;
+    trace!(
+      logger,
+      "Implementation prereqs did_run: {}",
+      prereqs_did_run
+    );
+
+    trace!(logger, "Running implementation ...");
+    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?;
+    debug!(logger, "done.");
+
+    Ok((location, did_run))
+  }
+}