Function applier

pub fn applier<K, QueueStream, ReconcilerFut, Ctx>(
    reconciler: impl FnMut(Arc<K>, Arc<Ctx>) -> ReconcilerFut,
    error_policy: impl Fn(Arc<K>, &<ReconcilerFut as TryFuture>::Error, Arc<Ctx>) -> Action,
    context: Arc<Ctx>,
    store: Store<K>,
    queue: QueueStream,
    config: Config,
) -> impl Stream<Item = Result<(ObjectRef<K>, Action), Error<<ReconcilerFut as TryFuture>::Error, <QueueStream as TryStream>::Error>>>
where
    K: Clone + Resource + 'static,
    <K as Resource>::DynamicType: Debug + Eq + Hash + Clone + Unpin,
    ReconcilerFut: TryFuture<Ok = Action> + Unpin,
    <ReconcilerFut as TryFuture>::Error: Error + 'static,
    QueueStream: TryStream,
    <QueueStream as TryStream>::Ok: Into<ReconcileRequest<K>>,
    <QueueStream as TryStream>::Error: Error + 'static,

Apply a reconciler to an input stream, with a given retry policy

Takes a store parameter for the core objects, which should usually be updated by a reflector().

The queue indicates which objects should be reconciled. For the core objects this will usually be the reflector() (piped through trigger_self). If your core objects own any subobjects then you can also make them trigger reconciliations by merging the reflector() with a watcher() or reflector() for the subobject.

This is the “hard-mode” version of Controller, which allows you some more customization (such as triggering from arbitrary Streams), at the cost of being a bit more verbose.