Rm my notes

Signed-off-by: Matei David <[email protected]>

examples/shared_stream_controllers.rs

@@ -43,79 +43,6 @@ async fn main() -> anyhow::Result<()> {
     let reflector = shared_reflector(writer, watcher(pods.clone(), Default::default()));
 
 
-    // Building a controller
-    //
-    // 1. Controller uses a builder pattern to instantiate it with different
-    // configuration values. Each method called on it will return and consume
-    // Self.
-    //
-    // 2. When a controller is created (`new()` and `new_with()`) it will:
-    //    - create a new store (and return a writeable handle).
-    //    - create a new "trigger_selector"
-    //    - create a "trigger_self"
-    //      - a "trigger_self" accepts a reflector (created using a watch and
-    //      our store handle)
-    //
-    //  What are triggers:
-    //
-    //  * Each controller has a trigger_selector. It is a stream union. It
-    //  accepts a bunch of streams.
-    //    - there are some internals to how this is done, which I guess I'll
-    //    briefly cover, but `SelectAll` is a buffer.
-    //      - e.g. it buffers futures. Calling `next()` on it will return
-    //      whatever future resolves first.
-    //    - how do we compose a buffer with streams? we turn every stream into a
-    //    future. We turn them into a functional list, (car, cdr).
-    //      - e.g. each stream is turned into a future, when polled it returns (Item,
-    //      Tail)
-    //      - this is a `StreamFuture`, its Poll function is easy to understand
-    //    - and now, the buffer will drive them all into completion
-    //  * A trigger itself is just a ReconciliationRequest. It is a stream that
-    //  wraps an inner stream and maps the object to a ReconciliationRequest,
-    //  something that triggers a reconciliation.
-    //
-    //
-    //  Trigger helpers:
-    //  * Trigger with: is an adapter that will take a stream and transform it
-    //  according to a predicate / mapper.
-    //
-    //
-    // 3. When the controller is run:
-    //    - It accepts a function that will reconcile. This is a callback that
-    //    is called with an object that has triggered a reconciliation.
-    //    - It will take a function that handles errors (an error callback)
-    //
-    //    We can think of the applier as an actor. It owns the reconciliation
-    //    state. It has a function (reconciler) and a stream, for each element
-    //    in the stream, it applies the function.
-    //
-    //    The complexity for the applier comes from managing streams and
-    //    requeues. It has to deal with:
-    //    * Shutdown signals
-    //    * Requeues
-    //
-    //    Requeuing is done through a buffer structured as a channel.
-    //
-    //    The applier will start a "Runner". The runner is a scheduler that can
-    //    debounce events. The runner wraps a stream that is handled by the
-    //    applier;
-    //    * Basically, our input stream and the rescheduled stream both get
-    //    polled, events get sent to the runner.
-    //    * Events are then debounced
-    //    * Scheduler will get the relevant item from the store, and apply the
-    //    callback to the object.
-    //      - if it fails, it reschedules
-    //      - if it does not, it moves on.
-    //
-    //
-    //  So we create another stream from all streams that trigger
-    //  reconciliations and the scheduler, and that stream of everything will
-    //  end up being run through a debouncer.
-    //
-    //  The scheduler is a bit tricky since it needs to deal with concurrent
-    //  invocations and messages that have already been processed.
-    //
-
     tokio::spawn(
         Controller::for_shared_stream(reflector.applied_objects(), reader, ())
             .with_config(config.clone())